Refactor enum type

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

diff --git a/include/side/trace.h b/include/side/trace.h
index 04bfff451f1199f7202b2850e8cc6a5262bd37b8..bc5fa940ab2e5a698034f6fd240126e59eca85ca 100644 (file)
--- a/include/side/trace.h
+++ b/include/side/trace.h
@@ -76,14 +76,7 @@ enum side_type {
        SIDE_TYPE_VLA_BLOB,
 
        /* Enumeration types */
-       SIDE_TYPE_ENUM_U8,
-       SIDE_TYPE_ENUM_U16,
-       SIDE_TYPE_ENUM_U32,
-       SIDE_TYPE_ENUM_U64,
-       SIDE_TYPE_ENUM_S8,
-       SIDE_TYPE_ENUM_S16,
-       SIDE_TYPE_ENUM_S32,
-       SIDE_TYPE_ENUM_S64,
+       SIDE_TYPE_ENUM,
 
        SIDE_TYPE_ENUM_BITMAP8,
        SIDE_TYPE_ENUM_BITMAP16,
@@ -263,7 +256,11 @@ struct side_type_description {
                const struct side_type_struct *side_struct;
 
                /* Enumeration types */
-               const struct side_enum_mappings *side_enum_mappings;
+               struct {
+                       const struct side_type_description *elem_type;
+                       const struct side_enum_mappings *mappings;
+               } side_enum;
+
                const struct side_enum_bitmap_mappings *side_enum_bitmap_mappings;
                struct {
                        const struct side_type_description *elem_type;
@@ -540,32 +537,18 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_field_string(_name, _attr)                        _side_field(_name, side_type_string(SIDE_PARAM(_attr)))
 #define side_field_dynamic(_name, _attr)               _side_field(_name, side_type_dynamic(SIDE_PARAM(_attr)))
 
-#define side_type_enum(_type, _mappings) \
+#define side_type_enum(_elem_type, _mappings) \
        { \
-               .type = _type, \
+               .type = SIDE_TYPE_ENUM, \
                .u = { \
-                       .side_enum_mappings = _mappings, \
+                       .side_enum = { \
+                               .elem_type = _elem_type, \
+                               .mappings = _mappings, \
+                       }, \
                }, \
        }
-#define _side_field_enum(_name, _type, _mappings) \
-       _side_field(_name, side_type_enum(_type, SIDE_PARAM(_mappings)))
-
-#define side_field_enum_u8(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U8, SIDE_PARAM(_mappings))
-#define side_field_enum_u16(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U16, SIDE_PARAM(_mappings))
-#define side_field_enum_u32(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U32, SIDE_PARAM(_mappings))
-#define side_field_enum_u64(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_U64, SIDE_PARAM(_mappings))
-#define side_field_enum_s8(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S8, SIDE_PARAM(_mappings))
-#define side_field_enum_s16(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S16, SIDE_PARAM(_mappings))
-#define side_field_enum_s32(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S32, SIDE_PARAM(_mappings))
-#define side_field_enum_s64(_name, _mappings) \
-       _side_field_enum(_name, SIDE_TYPE_ENUM_S64, SIDE_PARAM(_mappings))
+#define side_field_enum(_name, _elem_type, _mappings) \
+       _side_field(_name, side_type_enum(SIDE_PARAM(_elem_type), SIDE_PARAM(_mappings)))
 
 #define side_type_enum_bitmap(_type, _mappings) \
        { \
@@ -708,14 +691,6 @@ struct side_tracer_dynamic_vla_visitor_ctx {
 #define side_arg_s32(_val)             { .type = SIDE_TYPE_S32, .u = { .side_s32 = (_val) } }
 #define side_arg_s64(_val)             { .type = SIDE_TYPE_S64, .u = { .side_s64 = (_val) } }
 #define side_arg_blob(_val)            { .type = SIDE_TYPE_BLOB, .u = { .side_blob = (_val) } }
-#define side_arg_enum_u8(_val)         { .type = SIDE_TYPE_ENUM_U8, .u = { .side_u8 = (_val) } }
-#define side_arg_enum_u16(_val)                { .type = SIDE_TYPE_ENUM_U16, .u = { .side_u16 = (_val) } }
-#define side_arg_enum_u32(_val)                { .type = SIDE_TYPE_ENUM_U32, .u = { .side_u32 = (_val) } }
-#define side_arg_enum_u64(_val)                { .type = SIDE_TYPE_ENUM_U64, .u = { .side_u64 = (_val) } }
-#define side_arg_enum_s8(_val)         { .type = SIDE_TYPE_ENUM_S8, .u = { .side_s8 = (_val) } }
-#define side_arg_enum_s16(_val)                { .type = SIDE_TYPE_ENUM_S16, .u = { .side_s16 = (_val) } }
-#define side_arg_enum_s32(_val)                { .type = SIDE_TYPE_ENUM_S32, .u = { .side_s32 = (_val) } }
-#define side_arg_enum_s64(_val)                { .type = SIDE_TYPE_ENUM_S64, .u = { .side_s64 = (_val) } }
 #define side_arg_enum_bitmap8(_val)    { .type = SIDE_TYPE_ENUM_BITMAP8, .u = { .side_u8 = (_val) } }
 #define side_arg_enum_bitmap16(_val)   { .type = SIDE_TYPE_ENUM_BITMAP16, .u = { .side_u16 = (_val) } }
 #define side_arg_enum_bitmap32(_val)   { .type = SIDE_TYPE_ENUM_BITMAP32, .u = { .side_u32 = (_val) } }

diff --git a/src/test.c b/src/test.c
index 29adb6f5889c0ca8fab85f5516bec75e6645a788..7f9aabda15c2305da447624800f3465e4f933d54 100644 (file)
--- a/src/test.c
+++ b/src/test.c
@@ -985,10 +985,10 @@ static side_define_enum(myenum,
 
 static side_define_event(my_provider_event_enum, "myprovider", "myeventenum", SIDE_LOGLEVEL_DEBUG,
        side_field_list(
-               side_field_enum_u32("5", &myenum),
-               side_field_enum_u64("400", &myenum),
-               side_field_enum_u8("200", &myenum),
-               side_field_enum_s8("-100", &myenum),
+               side_field_enum("5", side_elem(side_type_u32(side_attr_list())), &myenum),
+               side_field_enum("400", side_elem(side_type_u64(side_attr_list())), &myenum),
+               side_field_enum("200", side_elem(side_type_u8(side_attr_list())), &myenum),
+               side_field_enum("-100", side_elem(side_type_s8(side_attr_list())), &myenum),
        ),
        side_attr_list()
 );
@@ -999,10 +999,10 @@ void test_enum(void)
        my_provider_event_enum_enabled = 1;
        side_event(my_provider_event_enum,
                side_arg_list(
-                       side_arg_enum_u32(5),
-                       side_arg_enum_u64(400),
-                       side_arg_enum_u8(200),
-                       side_arg_enum_s8(-100),
+                       side_arg_u32(5),
+                       side_arg_u64(400),
+                       side_arg_u8(200),
+                       side_arg_s8(-100),
                )
        );
 }

diff --git a/src/tracer.c b/src/tracer.c
index 5e991b58263bcf024fc7b61c6ad3933ce1a762fa..3dc3fde885b2564321952defbf9bacdf28136cae 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -25,6 +25,8 @@ static
 void tracer_print_vla_fixint(const struct side_type_description *type_desc, const struct side_arg_vec *item);
 static
 void tracer_print_dynamic(const struct side_arg_dynamic_vec *dynamic_item);
+static
+void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item);
 
 static
 void tracer_print_attr_type(const struct side_attr *attr)
@@ -116,15 +118,51 @@ void print_attributes(const char *prefix_str, const struct side_attr *attr, uint
 }
 
 static
-void print_enum(const struct side_enum_mappings *side_enum_mappings, int64_t value)
+void print_enum(const struct side_type_description *type_desc, const struct side_arg_vec *item)
 {
+       const struct side_enum_mappings *mappings = type_desc->u.side_enum.mappings;
        int i, print_count = 0;
+       int64_t value;
 
-       print_attributes("attr: ", side_enum_mappings->attr, side_enum_mappings->nr_attr);
-       printf("%s", side_enum_mappings->nr_attr ? ", " : "");
-       printf("value: %" PRId64 ", labels: [ ", value);
-       for (i = 0; i < side_enum_mappings->nr_mappings; i++) {
-               const struct side_enum_mapping *mapping = &side_enum_mappings->mappings[i];
+       if (type_desc->u.side_enum.elem_type->type != item->type) {
+               printf("ERROR: Unexpected enum element type\n");
+               abort();
+       }
+       switch (item->type) {
+       case SIDE_TYPE_U8:
+               value = (int64_t) item->u.side_u8;
+               break;
+       case SIDE_TYPE_U16:
+               value = (int64_t) item->u.side_u16;
+               break;
+       case SIDE_TYPE_U32:
+               value = (int64_t) item->u.side_u32;
+               break;
+       case SIDE_TYPE_U64:
+               value = (int64_t) item->u.side_u64;
+               break;
+       case SIDE_TYPE_S8:
+               value = (int64_t) item->u.side_s8;
+               break;
+       case SIDE_TYPE_S16:
+               value = (int64_t) item->u.side_s16;
+               break;
+       case SIDE_TYPE_S32:
+               value = (int64_t) item->u.side_s32;
+               break;
+       case SIDE_TYPE_S64:
+               value = (int64_t) item->u.side_s64;
+               break;
+       default:
+               printf("ERROR: Unexpected enum element type\n");
+               abort();
+       }
+       print_attributes("attr: ", mappings->attr, mappings->nr_attr);
+       printf("%s", mappings->nr_attr ? ", " : "");
+       tracer_print_type(type_desc->u.side_enum.elem_type, item);
+       printf(", labels: [ ");
+       for (i = 0; i < mappings->nr_mappings; i++) {
+               const struct side_enum_mapping *mapping = &mappings->mappings[i];
 
                if (mapping->range_end < mapping->range_begin) {
                        printf("ERROR: Unexpected enum range: %" PRIu64 "-%" PRIu64 "\n",
@@ -292,6 +330,8 @@ void tracer_print_basic_type_header(const struct side_type_description *type_des
 static
 void tracer_print_type(const struct side_type_description *type_desc, const struct side_arg_vec *item)
 {
+       enum side_type type;
+
        switch (item->type) {
        case SIDE_TYPE_ARRAY_U8:
        case SIDE_TYPE_ARRAY_U16:
@@ -322,6 +362,20 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                }
                break;
 
+       case SIDE_TYPE_U8:
+       case SIDE_TYPE_U16:
+       case SIDE_TYPE_U32:
+       case SIDE_TYPE_U64:
+       case SIDE_TYPE_S8:
+       case SIDE_TYPE_S16:
+       case SIDE_TYPE_S32:
+       case SIDE_TYPE_S64:
+               if (type_desc->type != item->type && type_desc->type != SIDE_TYPE_ENUM) {
+                       printf("ERROR: type mismatch between description and arguments\n");
+                       abort();
+               }
+               break;
+
        default:
                if (type_desc->type != item->type) {
                        printf("ERROR: type mismatch between description and arguments\n");
@@ -329,8 +383,14 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                }
                break;
        }
+
+       if (type_desc->type == SIDE_TYPE_ENUM)
+               type = SIDE_TYPE_ENUM;
+       else
+               type = item->type;
+
        printf("{ ");
-       switch (item->type) {
+       switch (type) {
        case SIDE_TYPE_BOOL:
                tracer_print_basic_type_header(type_desc);
                printf("%s", item->u.side_bool ? "true" : "false");
@@ -372,37 +432,8 @@ void tracer_print_type(const struct side_type_description *type_desc, const stru
                printf("0x%" PRIx8, item->u.side_blob);
                break;
 
-       case SIDE_TYPE_ENUM_U8:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_u8);
-               break;
-       case SIDE_TYPE_ENUM_U16:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_u16);
-               break;
-       case SIDE_TYPE_ENUM_U32:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_u32);
-               break;
-       case SIDE_TYPE_ENUM_U64:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_u64);
-               break;
-       case SIDE_TYPE_ENUM_S8:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_s8);
-               break;
-       case SIDE_TYPE_ENUM_S16:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_s16);
-               break;
-       case SIDE_TYPE_ENUM_S32:
-               print_enum(type_desc->u.side_enum_mappings,
-                       (int64_t) item->u.side_s32);
-               break;
-       case SIDE_TYPE_ENUM_S64:
-               print_enum(type_desc->u.side_enum_mappings,
-                       item->u.side_s64);
+       case SIDE_TYPE_ENUM:
+               print_enum(type_desc, item);
                break;
 
        case SIDE_TYPE_ENUM_BITMAP8:    /* Fall-through */