Remove enum before/after for arg vec visitor

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

diff --git a/src/tracer.c b/src/tracer.c
index eaff7b2da3404f5ebfb4e618e400170dfff4f31b..e52b0ceace80391a8d0eb30f56ad61a3182f471e 100644 (file)
--- a/src/tracer.c
+++ b/src/tracer.c
@@ -997,8 +997,7 @@ void inc_nested_item_nr(struct print_ctx *ctx)
 }
 
 static
-void tracer_print_event(enum side_type_visitor_location loc,
-               const struct side_event_description *desc,
+void tracer_before_print_event(const struct side_event_description *desc,
                const struct side_arg_vec *side_arg_vec,
                const struct side_arg_dynamic_struct *var_struct __attribute__((unused)),
                void *caller_addr, void *priv __attribute__((unused)))
@@ -1010,99 +1009,105 @@ void tracer_print_event(enum side_type_visitor_location loc,
                abort();
        }
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               if (print_caller)
-                       printf("caller: [%p], ", caller_addr);
-               printf("provider: %s, event: %s",
-                       side_ptr_get(desc->provider_name),
-                       side_ptr_get(desc->event_name));
-               print_attributes(", attr", ":", side_ptr_get(desc->attr), desc->nr_attr);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               printf("\n");
-               break;
-       }
+       if (print_caller)
+               printf("caller: [%p], ", caller_addr);
+       printf("provider: %s, event: %s",
+               side_ptr_get(desc->provider_name),
+               side_ptr_get(desc->event_name));
+       print_attributes(", attr", ":", side_ptr_get(desc->attr), desc->nr_attr);
 }
 
 static
-void tracer_print_static_fields(enum side_type_visitor_location loc,
-               const struct side_arg_vec *side_arg_vec,
-               void *priv)
+void tracer_after_print_event(const struct side_event_description *desc __attribute__((unused)),
+               const struct side_arg_vec *side_arg_vec __attribute__((unused)),
+               const struct side_arg_dynamic_struct *var_struct __attribute__((unused)),
+               void *caller_addr __attribute__((unused)), void *priv __attribute__((unused)))
+{
+       printf("\n");
+}
+
+static
+void tracer_before_print_static_fields(const struct side_arg_vec *side_arg_vec, void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
        uint32_t side_sav_len = side_arg_vec->len;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               printf("%s", side_sav_len ? ", fields: {" : "");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               if (side_sav_len)
-                       printf(" }");
-               break;
-       }
+       printf("%s", side_sav_len ? ", fields: {" : "");
+       push_nesting(ctx);
 }
 
+
 static
-void tracer_print_variadic_fields(enum side_type_visitor_location loc,
-               const struct side_arg_dynamic_struct *var_struct,
+void tracer_after_print_static_fields(const struct side_arg_vec *side_arg_vec, void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+       uint32_t side_sav_len = side_arg_vec->len;
+
+       pop_nesting(ctx);
+       if (side_sav_len)
+               printf(" }");
+}
+
+static
+void tracer_before_print_variadic_fields(const struct side_arg_dynamic_struct *var_struct,
                void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
        uint32_t var_struct_len = var_struct->len;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes(", attr ", "::", side_ptr_get(var_struct->attr), var_struct->nr_attr);
-               printf("%s", var_struct_len ? ", fields:: {" : "");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               if (var_struct_len)
-                       printf(" }");
-               break;
-       }
+       print_attributes(", attr ", "::", side_ptr_get(var_struct->attr), var_struct->nr_attr);
+       printf("%s", var_struct_len ? ", fields:: {" : "");
+       push_nesting(ctx);
 }
 
 static
-void tracer_print_field(enum side_type_visitor_location loc, const struct side_event_field *item_desc, void *priv)
+void tracer_after_print_variadic_fields(const struct side_arg_dynamic_struct *var_struct, void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
+       uint32_t var_struct_len = var_struct->len;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               if (get_nested_item_nr(ctx) != 0)
-                       printf(",");
-               printf(" %s: { ", side_ptr_get(item_desc->field_name));
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
+       pop_nesting(ctx);
+       if (var_struct_len)
                printf(" }");
-               inc_nested_item_nr(ctx);
-               break;
-       }
 }
 
 static
-void tracer_print_elem(enum side_type_visitor_location loc, const struct side_type *type_desc __attribute__((unused)), void *priv)
+void tracer_before_print_field(const struct side_event_field *item_desc, void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               if (get_nested_item_nr(ctx) != 0)
-                       printf(", { ");
-               else
-                       printf(" { ");
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               printf(" }");
-               inc_nested_item_nr(ctx);
-               break;
-       }
+       if (get_nested_item_nr(ctx) != 0)
+               printf(",");
+       printf(" %s: { ", side_ptr_get(item_desc->field_name));
+}
+
+static
+void tracer_after_print_field(const struct side_event_field *item_desc __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       printf(" }");
+       inc_nested_item_nr(ctx);
+}
+
+static
+void tracer_before_print_elem(const struct side_type *type_desc __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       if (get_nested_item_nr(ctx) != 0)
+               printf(", { ");
+       else
+               printf(" { ");
+}
+
+static
+void tracer_after_print_elem(const struct side_type *type_desc __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       printf(" }");
+       inc_nested_item_nr(ctx);
 }
 
 static
@@ -1168,71 +1173,75 @@ void tracer_print_string(const struct side_type *type_desc,
 }
 
 static
-void tracer_print_struct(enum side_type_visitor_location loc,
-       const struct side_type_struct *side_struct,
+void tracer_before_print_struct(const struct side_type_struct *side_struct,
        const struct side_arg_vec *side_arg_vec __attribute__((unused)), void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", ":", side_ptr_get(side_struct->attr), side_struct->nr_attr);
-               printf("%s", side_struct->nr_attr ? ", " : "");
-               printf("fields: {");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" }");
-               break;
-       }
+       print_attributes("attr", ":", side_ptr_get(side_struct->attr), side_struct->nr_attr);
+       printf("%s", side_struct->nr_attr ? ", " : "");
+       printf("fields: {");
+       push_nesting(ctx);
 }
 
+
 static
-void tracer_print_array(enum side_type_visitor_location loc,
-       const struct side_type_array *side_array,
+void tracer_after_print_struct(const struct side_type_struct *side_struct __attribute__((unused)),
        const struct side_arg_vec *side_arg_vec __attribute__((unused)), void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", ":", side_ptr_get(side_array->attr), side_array->nr_attr);
-               printf("%s", side_array->nr_attr ? ", " : "");
-               printf("elements: [");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" ]");
-               break;
-       }
+       pop_nesting(ctx);
+       printf(" }");
 }
 
 static
-void do_tracer_print_vla(enum side_type_visitor_location loc,
-       const struct side_type_vla *side_vla,
+void tracer_before_print_array(const struct side_type_array *side_array,
        const struct side_arg_vec *side_arg_vec __attribute__((unused)), void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", ":", side_ptr_get(side_vla->attr), side_vla->nr_attr);
-               printf("%s", side_vla->nr_attr ? ", " : "");
-               printf("elements: [");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" ]");
-               break;
-       }
+       print_attributes("attr", ":", side_ptr_get(side_array->attr), side_array->nr_attr);
+       printf("%s", side_array->nr_attr ? ", " : "");
+       printf("elements: [");
+       push_nesting(ctx);
+}
+
+static
+void tracer_after_print_array(const struct side_type_array *side_array __attribute__((unused)),
+       const struct side_arg_vec *side_arg_vec __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       pop_nesting(ctx);
+       printf(" ]");
+}
+
+static
+void do_tracer_before_print_vla(const struct side_type_vla *side_vla,
+       const struct side_arg_vec *side_arg_vec __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       print_attributes("attr", ":", side_ptr_get(side_vla->attr), side_vla->nr_attr);
+       printf("%s", side_vla->nr_attr ? ", " : "");
+       printf("elements: [");
+       push_nesting(ctx);
 }
 
+
 static
-void tracer_print_vla(enum side_type_visitor_location loc,
-       const struct side_type_vla *side_vla,
+void do_tracer_after_print_vla(const struct side_type_vla *side_vla __attribute__((unused)),
+       const struct side_arg_vec *side_arg_vec __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       pop_nesting(ctx);
+       printf(" ]");
+}
+
+static
+void tracer_before_print_vla(const struct side_type_vla *side_vla,
        const struct side_arg_vec *side_arg_vec, void *priv)
 {
        switch (side_enum_get(side_ptr_get(side_vla->length_type)->type)) {
@@ -1251,12 +1260,18 @@ void tracer_print_vla(enum side_type_visitor_location loc,
                fprintf(stderr, "ERROR: Unexpected vla length type\n");
                abort();
        }
-       do_tracer_print_vla(loc, side_vla, side_arg_vec, priv);
+       do_tracer_before_print_vla(side_vla, side_arg_vec, priv);
+}
+
+static
+void tracer_after_print_vla(const struct side_type_vla *side_vla,
+       const struct side_arg_vec *side_arg_vec, void *priv)
+{
+       do_tracer_after_print_vla(side_vla, side_arg_vec, priv);
 }
 
 static
-void tracer_print_vla_visitor(enum side_type_visitor_location loc,
-       const struct side_type_vla_visitor *side_vla_visitor,
+void tracer_before_print_vla_visitor(const struct side_type_vla_visitor *side_vla_visitor,
        const struct side_arg_vla_visitor *side_arg_vla_visitor __attribute__((unused)), void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
@@ -1278,18 +1293,20 @@ void tracer_print_vla_visitor(enum side_type_visitor_location loc,
                abort();
        }
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", ":", side_ptr_get(side_vla_visitor->attr), side_vla_visitor->nr_attr);
-               printf("%s", side_vla_visitor->nr_attr ? ", " : "");
-               printf("elements: [");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" ]");
-               break;
-       }
+       print_attributes("attr", ":", side_ptr_get(side_vla_visitor->attr), side_vla_visitor->nr_attr);
+       printf("%s", side_vla_visitor->nr_attr ? ", " : "");
+       printf("elements: [");
+       push_nesting(ctx);
+}
+
+static
+void tracer_after_print_vla_visitor(const struct side_type_vla_visitor *side_vla_visitor __attribute__((unused)),
+       const struct side_arg_vla_visitor *side_arg_vla_visitor __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       pop_nesting(ctx);
+       printf(" ]");
 }
 
 static void tracer_print_enum(const struct side_type *type_desc,
@@ -1456,26 +1473,32 @@ void tracer_print_gather_string(const struct side_type_gather_string *type,
 }
 
 static
-void tracer_print_gather_struct(enum side_type_visitor_location loc,
-       const struct side_type_struct *side_struct,
-       void *priv)
+void tracer_before_print_gather_struct(const struct side_type_struct *side_struct, void *priv)
 {
-       tracer_print_struct(loc, side_struct, NULL, priv);
+       tracer_before_print_struct(side_struct, NULL, priv);
 }
 
 static
-void tracer_print_gather_array(enum side_type_visitor_location loc,
-       const struct side_type_array *side_array,
-       void *priv)
+void tracer_after_print_gather_struct(const struct side_type_struct *side_struct, void *priv)
 {
-       tracer_print_array(loc, side_array, NULL, priv);
+       tracer_after_print_struct(side_struct, NULL, priv);
 }
 
 static
-void tracer_print_gather_vla(enum side_type_visitor_location loc,
-       const struct side_type_vla *side_vla,
-       uint32_t length __attribute__((unused)),
-       void *priv)
+void tracer_before_print_gather_array(const struct side_type_array *side_array, void *priv)
+{
+       tracer_before_print_array(side_array, NULL, priv);
+}
+
+static
+void tracer_after_print_gather_array(const struct side_type_array *side_array, void *priv)
+{
+       tracer_after_print_array(side_array, NULL, priv);
+}
+
+static
+void tracer_before_print_gather_vla(const struct side_type_vla *side_vla,
+       uint32_t length __attribute__((unused)), void *priv)
 {
        switch (side_enum_get(side_ptr_get(side_vla->length_type)->type)) {
        case SIDE_TYPE_GATHER_INTEGER:
@@ -1484,7 +1507,15 @@ void tracer_print_gather_vla(enum side_type_visitor_location loc,
                fprintf(stderr, "ERROR: Unexpected vla length type\n");
                abort();
        }
-       do_tracer_print_vla(loc, side_vla, NULL, priv);
+       do_tracer_before_print_vla(side_vla, NULL, priv);
+}
+
+
+static
+void tracer_after_print_gather_vla(const struct side_type_vla *side_vla,
+       uint32_t length __attribute__((unused)), void *priv)
+{
+       do_tracer_after_print_vla(side_vla, NULL, priv);
 }
 
 static
@@ -1507,28 +1538,34 @@ void tracer_print_gather_enum(const struct side_type_gather_enum *type,
 }
 
 static
-void tracer_print_dynamic_field(enum side_type_visitor_location loc, const struct side_arg_dynamic_field *field, void *priv)
+void tracer_before_print_dynamic_field(const struct side_arg_dynamic_field *field, void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               if (get_nested_item_nr(ctx) != 0)
-                       printf(",");
-               printf(" %s:: { ", side_ptr_get(field->field_name));
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               printf(" }");
-               inc_nested_item_nr(ctx);
-               break;
-       }
+       if (get_nested_item_nr(ctx) != 0)
+               printf(",");
+       printf(" %s:: { ", side_ptr_get(field->field_name));
+}
+
+static
+void tracer_after_print_dynamic_field(const struct side_arg_dynamic_field *field __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       printf(" }");
+       inc_nested_item_nr(ctx);
+}
+
+static
+void tracer_before_print_dynamic_elem(const struct side_arg *dynamic_item __attribute__((unused)), void *priv)
+{
+       tracer_before_print_elem(NULL, priv);
 }
 
 static
-void tracer_print_dynamic_elem(enum side_type_visitor_location loc,
-       const struct side_arg *dynamic_item __attribute__((unused)), void *priv)
+void tracer_after_print_dynamic_elem(const struct side_arg *dynamic_item __attribute__((unused)), void *priv)
 {
-       tracer_print_elem(loc, NULL, priv);
+       tracer_after_print_elem(NULL, priv);
 }
 
 static
@@ -1590,30 +1627,29 @@ void tracer_print_dynamic_string(const struct side_arg *item,
 }
 
 static
-void tracer_print_dynamic_struct(enum side_type_visitor_location loc,
-       const struct side_arg_dynamic_struct *dynamic_struct,
+void tracer_before_print_dynamic_struct(const struct side_arg_dynamic_struct *dynamic_struct,
        void *priv)
 {
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", "::", side_ptr_get(dynamic_struct->attr), dynamic_struct->nr_attr);
-               printf("%s", dynamic_struct->nr_attr ? ", " : "");
-               printf("fields:: {");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" }");
-               break;
-       }
+       print_attributes("attr", "::", side_ptr_get(dynamic_struct->attr), dynamic_struct->nr_attr);
+       printf("%s", dynamic_struct->nr_attr ? ", " : "");
+       printf("fields:: {");
+       push_nesting(ctx);
 }
 
 static
-void tracer_print_dynamic_struct_visitor(enum side_type_visitor_location loc,
-       const struct side_arg *item,
+void tracer_after_print_dynamic_struct(const struct side_arg_dynamic_struct *dynamic_struct __attribute__((unused)),
        void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       pop_nesting(ctx);
+       printf(" }");
+}
+
+static
+void tracer_before_print_dynamic_struct_visitor(const struct side_arg *item, void *priv)
 {
        struct side_arg_dynamic_struct_visitor *dynamic_struct_visitor;
        struct print_ctx *ctx = (struct print_ctx *) priv;
@@ -1622,45 +1658,48 @@ void tracer_print_dynamic_struct_visitor(enum side_type_visitor_location loc,
        if (!dynamic_struct_visitor)
                abort();
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", "::", side_ptr_get(dynamic_struct_visitor->attr), dynamic_struct_visitor->nr_attr);
-               printf("%s", dynamic_struct_visitor->nr_attr ? ", " : "");
-               printf("fields:: {");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" }");
-               break;
-       }
+       print_attributes("attr", "::", side_ptr_get(dynamic_struct_visitor->attr), dynamic_struct_visitor->nr_attr);
+       printf("%s", dynamic_struct_visitor->nr_attr ? ", " : "");
+       printf("fields:: {");
+       push_nesting(ctx);
 }
 
 static
-void tracer_print_dynamic_vla(enum side_type_visitor_location loc,
-       const struct side_arg_dynamic_vla *dynamic_vla,
-       void *priv)
+void tracer_after_print_dynamic_struct_visitor(const struct side_arg *item, void *priv)
 {
+       struct side_arg_dynamic_struct_visitor *dynamic_struct_visitor;
        struct print_ctx *ctx = (struct print_ctx *) priv;
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", "::", side_ptr_get(dynamic_vla->attr), dynamic_vla->nr_attr);
-               printf("%s", dynamic_vla->nr_attr ? ", " : "");
-               printf("elements:: [");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" ]");
-               break;
-       }
+       dynamic_struct_visitor = side_ptr_get(item->u.side_dynamic.side_dynamic_struct_visitor);
+       if (!dynamic_struct_visitor)
+               abort();
+
+       pop_nesting(ctx);
+       printf(" }");
 }
 
 static
-void tracer_print_dynamic_vla_visitor(enum side_type_visitor_location loc,
-       const struct side_arg *item,
-       void *priv)
+void tracer_before_print_dynamic_vla(const struct side_arg_dynamic_vla *dynamic_vla, void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       print_attributes("attr", "::", side_ptr_get(dynamic_vla->attr), dynamic_vla->nr_attr);
+       printf("%s", dynamic_vla->nr_attr ? ", " : "");
+       printf("elements:: [");
+       push_nesting(ctx);
+}
+
+static
+void tracer_after_print_dynamic_vla(const struct side_arg_dynamic_vla *dynamic_vla __attribute__((unused)), void *priv)
+{
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       pop_nesting(ctx);
+       printf(" ]");
+}
+
+static
+void tracer_before_print_dynamic_vla_visitor(const struct side_arg *item, void *priv)
 {
        struct side_arg_dynamic_vla_visitor *dynamic_vla_visitor;
        struct print_ctx *ctx = (struct print_ctx *) priv;
@@ -1669,28 +1708,39 @@ void tracer_print_dynamic_vla_visitor(enum side_type_visitor_location loc,
        if (!dynamic_vla_visitor)
                abort();
 
-       switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
-               print_attributes("attr", "::", side_ptr_get(dynamic_vla_visitor->attr), dynamic_vla_visitor->nr_attr);
-               printf("%s", dynamic_vla_visitor->nr_attr ? ", " : "");
-               printf("elements:: [");
-               push_nesting(ctx);
-               break;
-       case SIDE_TYPE_VISITOR_AFTER:
-               pop_nesting(ctx);
-               printf(" ]");
-               break;
-       }
+       print_attributes("attr", "::", side_ptr_get(dynamic_vla_visitor->attr), dynamic_vla_visitor->nr_attr);
+       printf("%s", dynamic_vla_visitor->nr_attr ? ", " : "");
+       printf("elements:: [");
+       push_nesting(ctx);
+}
+
+static
+void tracer_after_print_dynamic_vla_visitor(const struct side_arg *item, void *priv)
+{
+       struct side_arg_dynamic_vla_visitor *dynamic_vla_visitor;
+       struct print_ctx *ctx = (struct print_ctx *) priv;
+
+       dynamic_vla_visitor = side_ptr_get(item->u.side_dynamic.side_dynamic_vla_visitor);
+       if (!dynamic_vla_visitor)
+               abort();
+
+       pop_nesting(ctx);
+       printf(" ]");
 }
 
 static struct side_type_visitor type_visitor = {
-       .event_func = tracer_print_event,
-       .static_fields_func = tracer_print_static_fields,
-       .variadic_fields_func = tracer_print_variadic_fields,
+       .before_event_func = tracer_before_print_event,
+       .after_event_func = tracer_after_print_event,
+       .before_static_fields_func = tracer_before_print_static_fields,
+       .after_static_fields_func = tracer_after_print_static_fields,
+       .before_variadic_fields_func = tracer_before_print_variadic_fields,
+       .after_variadic_fields_func = tracer_after_print_variadic_fields,
 
        /* Stack-copy basic types. */
-       .field_func = tracer_print_field,
-       .elem_func = tracer_print_elem,
+       .before_field_func = tracer_before_print_field,
+       .after_field_func = tracer_after_print_field,
+       .before_elem_func = tracer_before_print_elem,
+       .after_elem_func = tracer_after_print_elem,
        .null_type_func = tracer_print_null,
        .bool_type_func = tracer_print_bool,
        .integer_type_func = tracer_print_integer,
@@ -1700,10 +1750,14 @@ static struct side_type_visitor type_visitor = {
        .string_type_func = tracer_print_string,
 
        /* Stack-copy compound types. */
-       .struct_type_func = tracer_print_struct,
-       .array_type_func = tracer_print_array,
-       .vla_type_func = tracer_print_vla,
-       .vla_visitor_type_func = tracer_print_vla_visitor,
+       .before_struct_type_func = tracer_before_print_struct,
+       .after_struct_type_func = tracer_after_print_struct,
+       .before_array_type_func = tracer_before_print_array,
+       .after_array_type_func = tracer_after_print_array,
+       .before_vla_type_func = tracer_before_print_vla,
+       .after_vla_type_func = tracer_after_print_vla,
+       .before_vla_visitor_type_func = tracer_before_print_vla_visitor,
+       .after_vla_visitor_type_func = tracer_after_print_vla_visitor,
 
        /* Stack-copy enumeration types. */
        .enum_type_func = tracer_print_enum,
@@ -1718,16 +1772,21 @@ static struct side_type_visitor type_visitor = {
        .gather_string_type_func = tracer_print_gather_string,
 
        /* Gather compound types. */
-       .gather_struct_type_func = tracer_print_gather_struct,
-       .gather_array_type_func = tracer_print_gather_array,
-       .gather_vla_type_func = tracer_print_gather_vla,
+       .before_gather_struct_type_func = tracer_before_print_gather_struct,
+       .after_gather_struct_type_func = tracer_after_print_gather_struct,
+       .before_gather_array_type_func = tracer_before_print_gather_array,
+       .after_gather_array_type_func = tracer_after_print_gather_array,
+       .before_gather_vla_type_func = tracer_before_print_gather_vla,
+       .after_gather_vla_type_func = tracer_after_print_gather_vla,
 
        /* Gather enumeration types. */
        .gather_enum_type_func = tracer_print_gather_enum,
 
        /* Dynamic basic types. */
-       .dynamic_field_func = tracer_print_dynamic_field,
-       .dynamic_elem_func = tracer_print_dynamic_elem,
+       .before_dynamic_field_func = tracer_before_print_dynamic_field,
+       .after_dynamic_field_func = tracer_after_print_dynamic_field,
+       .before_dynamic_elem_func = tracer_before_print_dynamic_elem,
+       .after_dynamic_elem_func = tracer_after_print_dynamic_elem,
 
        .dynamic_null_func = tracer_print_dynamic_null,
        .dynamic_bool_func = tracer_print_dynamic_bool,
@@ -1738,10 +1797,14 @@ static struct side_type_visitor type_visitor = {
        .dynamic_string_func = tracer_print_dynamic_string,
 
        /* Dynamic compound types. */
-       .dynamic_struct_func = tracer_print_dynamic_struct,
-       .dynamic_struct_visitor_func = tracer_print_dynamic_struct_visitor,
-       .dynamic_vla_func = tracer_print_dynamic_vla,
-       .dynamic_vla_visitor_func = tracer_print_dynamic_vla_visitor,
+       .before_dynamic_struct_func = tracer_before_print_dynamic_struct,
+       .after_dynamic_struct_func = tracer_after_print_dynamic_struct,
+       .before_dynamic_struct_visitor_func = tracer_before_print_dynamic_struct_visitor,
+       .after_dynamic_struct_visitor_func = tracer_after_print_dynamic_struct_visitor,
+       .before_dynamic_vla_func = tracer_before_print_dynamic_vla,
+       .after_dynamic_vla_func = tracer_after_print_dynamic_vla,
+       .before_dynamic_vla_visitor_func = tracer_before_print_dynamic_vla_visitor,
+       .after_dynamic_vla_visitor_func = tracer_after_print_dynamic_vla_visitor,
 };
 
 static
@@ -1773,11 +1836,11 @@ void print_description_event(enum side_description_visitor_location loc,
                void *priv __attribute__((unused)))
 {
        switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
+       case SIDE_DESCRIPTION_VISITOR_BEFORE:
                printf("event description: provider: %s, event: %s", side_ptr_get(desc->provider_name), side_ptr_get(desc->event_name));
                print_attributes(", attr", ":", side_ptr_get(desc->attr), desc->nr_attr);
                break;
-       case SIDE_TYPE_VISITOR_AFTER:
+       case SIDE_DESCRIPTION_VISITOR_AFTER:
                if (desc->flags & SIDE_EVENT_FLAG_VARIADIC)
                        printf(", <variadic fields>");
                printf("\n");
@@ -1794,11 +1857,11 @@ void print_description_static_fields(enum side_description_visitor_location loc,
        uint32_t len = desc->nr_fields;
 
        switch (loc) {
-       case SIDE_TYPE_VISITOR_BEFORE:
+       case SIDE_DESCRIPTION_VISITOR_BEFORE:
                printf("%s", len ? ", fields: {" : "");
                push_nesting(ctx);
                break;
-       case SIDE_TYPE_VISITOR_AFTER:
+       case SIDE_DESCRIPTION_VISITOR_AFTER:
                pop_nesting(ctx);
                if (len)
                        printf(" }");

diff --git a/src/visit-arg-vec.c b/src/visit-arg-vec.c
index b3d3a43770187fa8d7b2211882751693677a8975..b767e62848c9dafa893ace011a92acba3a9711a2 100644 (file)
--- a/src/visit-arg-vec.c
+++ b/src/visit-arg-vec.c
@@ -223,21 +223,21 @@ size_t type_visitor_strlen(const void *p, uint8_t unit_size)
 static
 void side_visit_elem(const struct side_type_visitor *type_visitor, const struct side_type *type_desc, const struct side_arg *item, void *priv)
 {
-       if (type_visitor->elem_func)
-               type_visitor->elem_func(SIDE_TYPE_VISITOR_BEFORE, type_desc, priv);
+       if (type_visitor->before_elem_func)
+               type_visitor->before_elem_func(type_desc, priv);
        side_visit_type(type_visitor, type_desc, item, priv);
-       if (type_visitor->elem_func)
-               type_visitor->elem_func(SIDE_TYPE_VISITOR_AFTER, type_desc, priv);
+       if (type_visitor->after_elem_func)
+               type_visitor->after_elem_func(type_desc, priv);
 }
 
 static
 void side_visit_field(const struct side_type_visitor *type_visitor, const struct side_event_field *item_desc, const struct side_arg *item, void *priv)
 {
-       if (type_visitor->field_func)
-               type_visitor->field_func(SIDE_TYPE_VISITOR_BEFORE, item_desc, priv);
+       if (type_visitor->before_field_func)
+               type_visitor->before_field_func(item_desc, priv);
        side_visit_type(type_visitor, &item_desc->side_type, item, priv);
-       if (type_visitor->field_func)
-               type_visitor->field_func(SIDE_TYPE_VISITOR_AFTER, item_desc, priv);
+       if (type_visitor->after_field_func)
+               type_visitor->after_field_func(item_desc, priv);
 }
 
 static
@@ -251,12 +251,12 @@ void type_visitor_struct(const struct side_type_visitor *type_visitor, const str
                fprintf(stderr, "ERROR: number of fields mismatch between description and arguments of structure\n");
                abort();
        }
-       if (type_visitor->struct_type_func)
-               type_visitor->struct_type_func(SIDE_TYPE_VISITOR_BEFORE, side_struct, side_arg_vec, priv);
+       if (type_visitor->before_struct_type_func)
+               type_visitor->before_struct_type_func(side_struct, side_arg_vec, priv);
        for (i = 0; i < side_sav_len; i++)
                side_visit_field(type_visitor, &side_ptr_get(side_struct->fields)[i], &sav[i], priv);
-       if (type_visitor->struct_type_func)
-               type_visitor->struct_type_func(SIDE_TYPE_VISITOR_AFTER, side_struct, side_arg_vec, priv);
+       if (type_visitor->after_struct_type_func)
+               type_visitor->after_struct_type_func(side_struct, side_arg_vec, priv);
 }
 
 static
@@ -312,12 +312,12 @@ void type_visitor_array(const struct side_type_visitor *type_visitor, const stru
                fprintf(stderr, "ERROR: length mismatch between description and arguments of array\n");
                abort();
        }
-       if (type_visitor->array_type_func)
-               type_visitor->array_type_func(SIDE_TYPE_VISITOR_BEFORE, &type_desc->u.side_array, side_arg_vec, priv);
+       if (type_visitor->before_array_type_func)
+               type_visitor->before_array_type_func(&type_desc->u.side_array, side_arg_vec, priv);
        for (i = 0; i < side_sav_len; i++)
                side_visit_elem(type_visitor, side_ptr_get(type_desc->u.side_array.elem_type), &sav[i], priv);
-       if (type_visitor->array_type_func)
-               type_visitor->array_type_func(SIDE_TYPE_VISITOR_AFTER, &type_desc->u.side_array, side_arg_vec, priv);
+       if (type_visitor->after_array_type_func)
+               type_visitor->after_array_type_func(&type_desc->u.side_array, side_arg_vec, priv);
 }
 
 static
@@ -326,12 +326,12 @@ void type_visitor_vla(const struct side_type_visitor *type_visitor, const struct
        const struct side_arg *sav = side_ptr_get(side_arg_vec->sav);
        uint32_t i, side_sav_len = side_arg_vec->len;
 
-       if (type_visitor->vla_type_func)
-               type_visitor->vla_type_func(SIDE_TYPE_VISITOR_BEFORE, &type_desc->u.side_vla, side_arg_vec, priv);
+       if (type_visitor->before_vla_type_func)
+               type_visitor->before_vla_type_func(&type_desc->u.side_vla, side_arg_vec, priv);
        for (i = 0; i < side_sav_len; i++)
                side_visit_elem(type_visitor, side_ptr_get(type_desc->u.side_vla.elem_type), &sav[i], priv);
-       if (type_visitor->vla_type_func)
-               type_visitor->vla_type_func(SIDE_TYPE_VISITOR_AFTER, &type_desc->u.side_vla, side_arg_vec, priv);
+       if (type_visitor->after_vla_type_func)
+               type_visitor->after_vla_type_func(&type_desc->u.side_vla, side_arg_vec, priv);
 }
 
 struct tracer_visitor_priv {
@@ -370,8 +370,8 @@ void type_visitor_vla_visitor(const struct side_type_visitor *type_visitor, cons
 
        if (!vla_visitor)
                abort();
-       if (type_visitor->vla_visitor_type_func)
-               type_visitor->vla_visitor_type_func(SIDE_TYPE_VISITOR_BEFORE, side_ptr_get(type_desc->u.side_vla_visitor), vla_visitor, priv);
+       if (type_visitor->before_vla_visitor_type_func)
+               type_visitor->before_vla_visitor_type_func(side_ptr_get(type_desc->u.side_vla_visitor), vla_visitor, priv);
        app_ctx = side_ptr_get(vla_visitor->app_ctx);
        func = side_ptr_get(side_ptr_get(type_desc->u.side_vla_visitor)->visitor);
        status = func(&tracer_ctx, app_ctx);
@@ -382,8 +382,8 @@ void type_visitor_vla_visitor(const struct side_type_visitor *type_visitor, cons
                fprintf(stderr, "ERROR: Visitor error\n");
                abort();
        }
-       if (type_visitor->vla_visitor_type_func)
-               type_visitor->vla_visitor_type_func(SIDE_TYPE_VISITOR_AFTER, side_ptr_get(type_desc->u.side_vla_visitor), vla_visitor, priv);
+       if (type_visitor->after_vla_visitor_type_func)
+               type_visitor->after_vla_visitor_type_func(side_ptr_get(type_desc->u.side_vla_visitor), vla_visitor, priv);
 }
 
 static
@@ -432,11 +432,11 @@ union int_value tracer_load_gather_integer_value(const struct side_type_gather_i
 static
 void visit_gather_field(const struct side_type_visitor *type_visitor, const struct side_event_field *field, const void *ptr, void *priv)
 {
-       if (type_visitor->field_func)
-               type_visitor->field_func(SIDE_TYPE_VISITOR_BEFORE, field, priv);
+       if (type_visitor->before_field_func)
+               type_visitor->before_field_func(field, priv);
        (void) visit_gather_type(type_visitor, &field->side_type, ptr, priv);
-       if (type_visitor->field_func)
-               type_visitor->field_func(SIDE_TYPE_VISITOR_AFTER, field, priv);
+       if (type_visitor->after_field_func)
+               type_visitor->after_field_func(field, priv);
 }
 
 static
@@ -447,13 +447,13 @@ uint32_t type_visitor_gather_struct(const struct side_type_visitor *type_visitor
        const char *ptr = (const char *) _ptr;
        uint32_t i;
 
-       if (type_visitor->gather_struct_type_func)
-               type_visitor->gather_struct_type_func(SIDE_TYPE_VISITOR_BEFORE, side_struct, priv);
+       if (type_visitor->before_gather_struct_type_func)
+               type_visitor->before_gather_struct_type_func(side_struct, priv);
        ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_struct.offset);
        for (i = 0; i < side_struct->nr_fields; i++)
                visit_gather_field(type_visitor, &side_ptr_get(side_struct->fields)[i], ptr, priv);
-       if (type_visitor->gather_struct_type_func)
-               type_visitor->gather_struct_type_func(SIDE_TYPE_VISITOR_AFTER, side_struct, priv);
+       if (type_visitor->after_gather_struct_type_func)
+               type_visitor->after_gather_struct_type_func(side_struct, priv);
        return tracer_gather_size(access_mode, type_gather->u.side_struct.size);
 }
 
@@ -465,8 +465,8 @@ uint32_t type_visitor_gather_array(const struct side_type_visitor *type_visitor,
        const char *ptr = (const char *) _ptr, *orig_ptr;
        uint32_t i;
 
-       if (type_visitor->gather_array_type_func)
-               type_visitor->gather_array_type_func(SIDE_TYPE_VISITOR_BEFORE, side_array, priv);
+       if (type_visitor->before_gather_array_type_func)
+               type_visitor->before_gather_array_type_func(side_array, priv);
        ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_array.offset);
        orig_ptr = ptr;
        for (i = 0; i < side_array->length; i++) {
@@ -481,8 +481,8 @@ uint32_t type_visitor_gather_array(const struct side_type_visitor *type_visitor,
                }
                ptr += visit_gather_elem(type_visitor, elem_type, ptr, priv);
        }
-       if (type_visitor->gather_array_type_func)
-               type_visitor->gather_array_type_func(SIDE_TYPE_VISITOR_AFTER, side_array, priv);
+       if (type_visitor->after_gather_array_type_func)
+               type_visitor->after_gather_array_type_func(side_array, priv);
        return tracer_gather_size(access_mode, ptr - orig_ptr);
 }
 
@@ -512,8 +512,8 @@ uint32_t type_visitor_gather_vla(const struct side_type_visitor *type_visitor, c
                abort();
        }
        length = (uint32_t) v.u[SIDE_INTEGER128_SPLIT_LOW];
-       if (type_visitor->gather_vla_type_func)
-               type_visitor->gather_vla_type_func(SIDE_TYPE_VISITOR_BEFORE, side_vla, length, priv);
+       if (type_visitor->before_gather_vla_type_func)
+               type_visitor->before_gather_vla_type_func(side_vla, length, priv);
        ptr = tracer_gather_access(access_mode, ptr + type_gather->u.side_vla.offset);
        orig_ptr = ptr;
        for (i = 0; i < length; i++) {
@@ -528,8 +528,8 @@ uint32_t type_visitor_gather_vla(const struct side_type_visitor *type_visitor, c
                }
                ptr += visit_gather_elem(type_visitor, elem_type, ptr, priv);
        }
-       if (type_visitor->gather_vla_type_func)
-               type_visitor->gather_vla_type_func(SIDE_TYPE_VISITOR_AFTER, side_vla, length, priv);
+       if (type_visitor->after_gather_vla_type_func)
+               type_visitor->after_gather_vla_type_func(side_vla, length, priv);
        return tracer_gather_size(access_mode, ptr - orig_ptr);
 }
 
@@ -704,11 +704,11 @@ uint32_t visit_gather_elem(const struct side_type_visitor *type_visitor, const s
 {
        uint32_t len;
 
-       if (type_visitor->elem_func)
-               type_visitor->elem_func(SIDE_TYPE_VISITOR_BEFORE, type_desc, priv);
+       if (type_visitor->before_elem_func)
+               type_visitor->before_elem_func(type_desc, priv);
        len = visit_gather_type(type_visitor, type_desc, ptr, priv);
-       if (type_visitor->elem_func)
-               type_visitor->elem_func(SIDE_TYPE_VISITOR_AFTER, type_desc, priv);
+       if (type_visitor->after_elem_func)
+               type_visitor->after_elem_func(type_desc, priv);
        return len;
 }
 
@@ -742,11 +742,11 @@ uint32_t type_visitor_gather_enum(const struct side_type_visitor *type_visitor,
 static
 void visit_dynamic_field(const struct side_type_visitor *type_visitor, const struct side_arg_dynamic_field *field, void *priv)
 {
-       if (type_visitor->dynamic_field_func)
-               type_visitor->dynamic_field_func(SIDE_TYPE_VISITOR_BEFORE, field, priv);
+       if (type_visitor->before_dynamic_field_func)
+               type_visitor->before_dynamic_field_func(field, priv);
        visit_dynamic_type(type_visitor, &field->elem, priv);
-       if (type_visitor->dynamic_field_func)
-               type_visitor->dynamic_field_func(SIDE_TYPE_VISITOR_AFTER, field, priv);
+       if (type_visitor->after_dynamic_field_func)
+               type_visitor->after_dynamic_field_func(field, priv);
 }
 
 static
@@ -755,12 +755,12 @@ void type_visitor_dynamic_struct(const struct side_type_visitor *type_visitor, c
        const struct side_arg_dynamic_field *fields = side_ptr_get(dynamic_struct->fields);
        uint32_t i, len = dynamic_struct->len;
 
-       if (type_visitor->dynamic_struct_func)
-               type_visitor->dynamic_struct_func(SIDE_TYPE_VISITOR_BEFORE, dynamic_struct, priv);
+       if (type_visitor->before_dynamic_struct_func)
+               type_visitor->before_dynamic_struct_func(dynamic_struct, priv);
        for (i = 0; i < len; i++)
                visit_dynamic_field(type_visitor, &fields[i], priv);
-       if (type_visitor->dynamic_struct_func)
-               type_visitor->dynamic_struct_func(SIDE_TYPE_VISITOR_AFTER, dynamic_struct, priv);
+       if (type_visitor->after_dynamic_struct_func)
+               type_visitor->after_dynamic_struct_func(dynamic_struct, priv);
 }
 
 struct tracer_dynamic_struct_visitor_priv {
@@ -797,8 +797,8 @@ void type_visitor_dynamic_struct_visitor(const struct side_type_visitor *type_vi
        enum side_visitor_status status;
        void *app_ctx;
 
-       if (type_visitor->dynamic_struct_visitor_func)
-               type_visitor->dynamic_struct_visitor_func(SIDE_TYPE_VISITOR_BEFORE, item, priv);
+       if (type_visitor->before_dynamic_struct_visitor_func)
+               type_visitor->before_dynamic_struct_visitor_func(item, priv);
        dynamic_struct_visitor = side_ptr_get(item->u.side_dynamic.side_dynamic_struct_visitor);
        if (!dynamic_struct_visitor)
                abort();
@@ -811,8 +811,8 @@ void type_visitor_dynamic_struct_visitor(const struct side_type_visitor *type_vi
                fprintf(stderr, "ERROR: Visitor error\n");
                abort();
        }
-       if (type_visitor->dynamic_struct_visitor_func)
-               type_visitor->dynamic_struct_visitor_func(SIDE_TYPE_VISITOR_AFTER, item, priv);
+       if (type_visitor->after_dynamic_struct_visitor_func)
+               type_visitor->after_dynamic_struct_visitor_func(item, priv);
 }
 
 static
@@ -821,12 +821,12 @@ void type_visitor_dynamic_vla(const struct side_type_visitor *type_visitor, cons
        const struct side_arg *sav = side_ptr_get(vla->sav);
        uint32_t i, side_sav_len = vla->len;
 
-       if (type_visitor->dynamic_vla_func)
-               type_visitor->dynamic_vla_func(SIDE_TYPE_VISITOR_BEFORE, vla, priv);
+       if (type_visitor->before_dynamic_vla_func)
+               type_visitor->before_dynamic_vla_func(vla, priv);
        for (i = 0; i < side_sav_len; i++)
                visit_dynamic_elem(type_visitor, &sav[i], priv);
-       if (type_visitor->dynamic_vla_func)
-               type_visitor->dynamic_vla_func(SIDE_TYPE_VISITOR_AFTER, vla, priv);
+       if (type_visitor->after_dynamic_vla_func)
+               type_visitor->after_dynamic_vla_func(vla, priv);
 }
 
 struct tracer_dynamic_vla_visitor_priv {
@@ -863,8 +863,8 @@ void type_visitor_dynamic_vla_visitor(const struct side_type_visitor *type_visit
        enum side_visitor_status status;
        void *app_ctx;
 
-       if (type_visitor->dynamic_vla_visitor_func)
-               type_visitor->dynamic_vla_visitor_func(SIDE_TYPE_VISITOR_BEFORE, item, priv);
+       if (type_visitor->before_dynamic_vla_visitor_func)
+               type_visitor->before_dynamic_vla_visitor_func(item, priv);
        dynamic_vla_visitor = side_ptr_get(item->u.side_dynamic.side_dynamic_vla_visitor);
        if (!dynamic_vla_visitor)
                abort();
@@ -877,8 +877,8 @@ void type_visitor_dynamic_vla_visitor(const struct side_type_visitor *type_visit
                fprintf(stderr, "ERROR: Visitor error\n");
                abort();
        }
-       if (type_visitor->dynamic_vla_visitor_func)
-               type_visitor->dynamic_vla_visitor_func(SIDE_TYPE_VISITOR_AFTER, item, priv);
+       if (type_visitor->after_dynamic_vla_visitor_func)
+               type_visitor->after_dynamic_vla_visitor_func(item, priv);
 }
 
 static
@@ -937,11 +937,11 @@ void visit_dynamic_type(const struct side_type_visitor *type_visitor, const stru
 static
 void visit_dynamic_elem(const struct side_type_visitor *type_visitor, const struct side_arg *dynamic_item, void *priv)
 {
-       if (type_visitor->elem_func)
-               type_visitor->dynamic_elem_func(SIDE_TYPE_VISITOR_BEFORE, dynamic_item, priv);
+       if (type_visitor->before_dynamic_elem_func)
+               type_visitor->before_dynamic_elem_func(dynamic_item, priv);
        visit_dynamic_type(type_visitor, dynamic_item, priv);
-       if (type_visitor->elem_func)
-               type_visitor->dynamic_elem_func(SIDE_TYPE_VISITOR_AFTER, dynamic_item, priv);
+       if (type_visitor->after_dynamic_elem_func)
+               type_visitor->after_dynamic_elem_func(dynamic_item, priv);
 }
 
 void side_visit_type(const struct side_type_visitor *type_visitor, const struct side_type *type_desc, const struct side_arg *item, void *priv)
@@ -1175,26 +1175,26 @@ void type_visitor_event(const struct side_type_visitor *type_visitor,
                fprintf(stderr, "ERROR: number of fields mismatch between description and arguments\n");
                abort();
        }
-       if (type_visitor->event_func)
-               type_visitor->event_func(SIDE_TYPE_VISITOR_BEFORE, desc, side_arg_vec, var_struct, caller_addr, priv);
+       if (type_visitor->before_event_func)
+               type_visitor->before_event_func(desc, side_arg_vec, var_struct, caller_addr, priv);
        if (side_sav_len) {
-               if (type_visitor->static_fields_func)
-                       type_visitor->static_fields_func(SIDE_TYPE_VISITOR_BEFORE, side_arg_vec, priv);
+               if (type_visitor->before_static_fields_func)
+                       type_visitor->before_static_fields_func(side_arg_vec, priv);
                for (i = 0; i < side_sav_len; i++)
                        side_visit_field(type_visitor, &side_ptr_get(desc->fields)[i], &sav[i], priv);
-               if (type_visitor->static_fields_func)
-                       type_visitor->static_fields_func(SIDE_TYPE_VISITOR_AFTER, side_arg_vec, priv);
+               if (type_visitor->after_static_fields_func)
+                       type_visitor->after_static_fields_func(side_arg_vec, priv);
        }
        if (var_struct) {
                uint32_t var_struct_len = var_struct->len;
 
-               if (type_visitor->variadic_fields_func)
-                       type_visitor->variadic_fields_func(SIDE_TYPE_VISITOR_BEFORE, var_struct, priv);
+               if (type_visitor->before_variadic_fields_func)
+                       type_visitor->before_variadic_fields_func(var_struct, priv);
                for (i = 0; i < var_struct_len; i++)
                        visit_dynamic_field(type_visitor, &side_ptr_get(var_struct->fields)[i], priv);
-               if (type_visitor->variadic_fields_func)
-                       type_visitor->variadic_fields_func(SIDE_TYPE_VISITOR_AFTER, var_struct, priv);
+               if (type_visitor->after_variadic_fields_func)
+                       type_visitor->after_variadic_fields_func(var_struct, priv);
        }
-       if (type_visitor->event_func)
-               type_visitor->event_func(SIDE_TYPE_VISITOR_AFTER, desc, side_arg_vec, var_struct, caller_addr, priv);
+       if (type_visitor->after_event_func)
+               type_visitor->after_event_func(desc, side_arg_vec, var_struct, caller_addr, priv);
 }

diff --git a/src/visit-arg-vec.h b/src/visit-arg-vec.h
index ab48ec70c53e14c9abf45c5ba7872e2deda044c6..30b15d4710aa72b5d8fe7a5ca7a4576b7b261742 100644 (file)
--- a/src/visit-arg-vec.h
+++ b/src/visit-arg-vec.h
@@ -8,30 +8,27 @@
 
 #include <side/trace.h>
 
-enum side_type_visitor_location {
-       SIDE_TYPE_VISITOR_BEFORE,
-       SIDE_TYPE_VISITOR_AFTER,
-};
-
 struct side_type_visitor {
-       void (*event_func)(enum side_type_visitor_location loc,
-                       const struct side_event_description *desc,
+       void (*before_event_func)(const struct side_event_description *desc,
                        const struct side_arg_vec *side_arg_vec,
                        const struct side_arg_dynamic_struct *var_struct,
-                       void *caller_addr,
-                       void *priv);
-
-       void (*static_fields_func)(enum side_type_visitor_location loc,
+                       void *caller_addr, void *priv);
+       void (*after_event_func)(const struct side_event_description *desc,
                        const struct side_arg_vec *side_arg_vec,
-                       void *priv);
-
-       void (*variadic_fields_func)(enum side_type_visitor_location loc,
                        const struct side_arg_dynamic_struct *var_struct,
-                       void *priv);
+                       void *caller_addr, void *priv);
+
+       void (*before_static_fields_func)(const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*after_static_fields_func)(const struct side_arg_vec *side_arg_vec, void *priv);
+
+       void (*before_variadic_fields_func)(const struct side_arg_dynamic_struct *var_struct, void *priv);
+       void (*after_variadic_fields_func)(const struct side_arg_dynamic_struct *var_struct, void *priv);
 
        /* Stack-copy basic types. */
-       void (*field_func)(enum side_type_visitor_location loc, const struct side_event_field *item_desc, void *priv);
-       void (*elem_func)(enum side_type_visitor_location loc, const struct side_type *type_desc, void *priv);
+       void (*before_field_func)(const struct side_event_field *item_desc, void *priv);
+       void (*after_field_func)(const struct side_event_field *item_desc, void *priv);
+       void (*before_elem_func)(const struct side_type *type_desc, void *priv);
+       void (*after_elem_func)(const struct side_type *type_desc, void *priv);
 
        void (*null_type_func)(const struct side_type *type_desc, const struct side_arg *item, void *priv);
        void (*bool_type_func)(const struct side_type *type_desc, const struct side_arg *item, void *priv);
@@ -42,10 +39,14 @@ struct side_type_visitor {
        void (*string_type_func)(const struct side_type *type_desc, const struct side_arg *item, void *priv);
 
        /* Stack-copy compound types. */
-       void (*struct_type_func)(enum side_type_visitor_location loc, const struct side_type_struct *side_struct, const struct side_arg_vec *side_arg_vec, void *priv);
-       void (*array_type_func)(enum side_type_visitor_location loc, const struct side_type_array *side_array, const struct side_arg_vec *side_arg_vec, void *priv);
-       void (*vla_type_func)(enum side_type_visitor_location loc, const struct side_type_vla *side_vla, const struct side_arg_vec *side_arg_vec, void *priv);
-       void (*vla_visitor_type_func)(enum side_type_visitor_location loc, const struct side_type_vla_visitor *side_vla_visitor, const struct side_arg_vla_visitor *side_arg_vla_visitor, void *priv);
+       void (*before_struct_type_func)(const struct side_type_struct *side_struct, const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*after_struct_type_func)(const struct side_type_struct *side_struct, const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*before_array_type_func)(const struct side_type_array *side_array, const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*after_array_type_func)(const struct side_type_array *side_array, const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*before_vla_type_func)(const struct side_type_vla *side_vla, const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*after_vla_type_func)(const struct side_type_vla *side_vla, const struct side_arg_vec *side_arg_vec, void *priv);
+       void (*before_vla_visitor_type_func)(const struct side_type_vla_visitor *side_vla_visitor, const struct side_arg_vla_visitor *side_arg_vla_visitor, void *priv);
+       void (*after_vla_visitor_type_func)(const struct side_type_vla_visitor *side_vla_visitor, const struct side_arg_vla_visitor *side_arg_vla_visitor, void *priv);
 
        /* Stack-copy enumeration types. */
        void (*enum_type_func)(const struct side_type *type_desc, const struct side_arg *item, void *priv);
@@ -61,16 +62,21 @@ struct side_type_visitor {
                                enum side_type_label_byte_order byte_order, size_t strlen_with_null, void *priv);
 
        /* Gather compound types. */
-       void (*gather_struct_type_func)(enum side_type_visitor_location loc, const struct side_type_struct *type, void *priv);
-       void (*gather_array_type_func)(enum side_type_visitor_location loc, const struct side_type_array *type, void *priv);
-       void (*gather_vla_type_func)(enum side_type_visitor_location loc, const struct side_type_vla *type, uint32_t length, void *priv);
+       void (*before_gather_struct_type_func)(const struct side_type_struct *type, void *priv);
+       void (*after_gather_struct_type_func)(const struct side_type_struct *type, void *priv);
+       void (*before_gather_array_type_func)(const struct side_type_array *type, void *priv);
+       void (*after_gather_array_type_func)(const struct side_type_array *type, void *priv);
+       void (*before_gather_vla_type_func)(const struct side_type_vla *type, uint32_t length, void *priv);
+       void (*after_gather_vla_type_func)(const struct side_type_vla *type, uint32_t length, void *priv);
 
        /* Gather enumeration types. */
        void (*gather_enum_type_func)(const struct side_type_gather_enum *type, const union side_integer_value *value, void *priv);
 
        /* Dynamic basic types. */
-       void (*dynamic_field_func)(enum side_type_visitor_location loc, const struct side_arg_dynamic_field *field, void *priv);
-       void (*dynamic_elem_func)(enum side_type_visitor_location loc, const struct side_arg *dynamic_item, void *priv);
+       void (*before_dynamic_field_func)(const struct side_arg_dynamic_field *field, void *priv);
+       void (*after_dynamic_field_func)(const struct side_arg_dynamic_field *field, void *priv);
+       void (*before_dynamic_elem_func)(const struct side_arg *dynamic_item, void *priv);
+       void (*after_dynamic_elem_func)(const struct side_arg *dynamic_item, void *priv);
 
        void (*dynamic_null_func)(const struct side_arg *item, void *priv);
        void (*dynamic_bool_func)(const struct side_arg *item, void *priv);
@@ -81,10 +87,14 @@ struct side_type_visitor {
        void (*dynamic_string_func)(const struct side_arg *item, void *priv);
 
        /* Dynamic compound types. */
-       void (*dynamic_struct_func)(enum side_type_visitor_location loc, const struct side_arg_dynamic_struct *dynamic_struct, void *priv);
-       void (*dynamic_struct_visitor_func)(enum side_type_visitor_location loc, const struct side_arg *item, void *priv);
-       void (*dynamic_vla_func)(enum side_type_visitor_location loc, const struct side_arg_dynamic_vla *vla, void *priv);
-       void (*dynamic_vla_visitor_func)(enum side_type_visitor_location loc, const struct side_arg *item, void *priv);
+       void (*before_dynamic_struct_func)(const struct side_arg_dynamic_struct *dynamic_struct, void *priv);
+       void (*after_dynamic_struct_func)(const struct side_arg_dynamic_struct *dynamic_struct, void *priv);
+       void (*before_dynamic_struct_visitor_func)(const struct side_arg *item, void *priv);
+       void (*after_dynamic_struct_visitor_func)(const struct side_arg *item, void *priv);
+       void (*before_dynamic_vla_func)(const struct side_arg_dynamic_vla *vla, void *priv);
+       void (*after_dynamic_vla_func)(const struct side_arg_dynamic_vla *vla, void *priv);
+       void (*before_dynamic_vla_visitor_func)(const struct side_arg *item, void *priv);
+       void (*after_dynamic_vla_visitor_func)(const struct side_arg *item, void *priv);
 };
 
 void type_visitor_event(const struct side_type_visitor *type_visitor,