`ctf` plugin: metadata: use local log level

[babeltrace.git] / src / plugins / ctf / common / metadata / visitor-parent-links.c

diff --git a/src/plugins/ctf/common/metadata/visitor-parent-links.c b/src/plugins/ctf/common/metadata/visitor-parent-links.c
index a7f0e93ecd076ab0522333a38b2754ccfa2e87e2..6b05a3389a2fca15addc853679b7948e53565972 100644 (file)
--- a/src/plugins/ctf/common/metadata/visitor-parent-links.c
+++ b/src/plugins/ctf/common/metadata/visitor-parent-links.c
@@ -24,8 +24,9 @@
  * SOFTWARE.
  */
 
+#define BT_LOG_OUTPUT_LEVEL log_level
 #define BT_LOG_TAG "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"
-#include "logging.h"
+#include "logging/log.h"
 
 #include <stdio.h>
 #include <unistd.h>
@@ -40,9 +41,11 @@
 #include "scanner.h"
 #include "parser.h"
 #include "ast.h"
+#include "logging.h"
 
 static
-int ctf_visitor_unary_expression(int depth, struct ctf_node *node)
+int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
+               bt_logging_level log_level)
 {
        int ret = 0;
 
@@ -67,7 +70,8 @@ int ctf_visitor_unary_expression(int depth, struct ctf_node *node)
        case UNARY_SBRAC:
                node->u.unary_expression.u.sbrac_exp->parent = node;
                ret = ctf_visitor_unary_expression(depth + 1,
-                       node->u.unary_expression.u.sbrac_exp);
+                       node->u.unary_expression.u.sbrac_exp,
+                       log_level);
                if (ret)
                        return ret;
                break;
@@ -83,7 +87,8 @@ int ctf_visitor_unary_expression(int depth, struct ctf_node *node)
 }
 
 static
-int ctf_visitor_type_specifier(int depth, struct ctf_node *node)
+int ctf_visitor_type_specifier(int depth, struct ctf_node *node,
+               bt_logging_level log_level)
 {
        int ret;
 
@@ -110,7 +115,9 @@ int ctf_visitor_type_specifier(int depth, struct ctf_node *node)
        case TYPESPEC_VARIANT:
        case TYPESPEC_ENUM:
                node->u.field_class_specifier.node->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_specifier.node);
+               ret = ctf_visitor_parent_links(depth + 1,
+                       node->u.field_class_specifier.node,
+                       log_level);
                if (ret)
                        return ret;
                break;
@@ -126,7 +133,8 @@ int ctf_visitor_type_specifier(int depth, struct ctf_node *node)
 }
 
 static
-int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node)
+int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
+               bt_logging_level log_level)
 {
        int ret = 0;
        struct ctf_node *iter;
@@ -136,7 +144,7 @@ int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node)
        bt_list_for_each_entry(iter, &node->u.field_class_declarator.pointers,
                                siblings) {
                iter->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, iter);
+               ret = ctf_visitor_parent_links(depth + 1, iter, log_level);
                if (ret)
                        return ret;
        }
@@ -148,7 +156,8 @@ int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node)
                if (node->u.field_class_declarator.u.nested.field_class_declarator) {
                        node->u.field_class_declarator.u.nested.field_class_declarator->parent = node;
                        ret = ctf_visitor_parent_links(depth + 1,
-                               node->u.field_class_declarator.u.nested.field_class_declarator);
+                               node->u.field_class_declarator.u.nested.field_class_declarator,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -156,7 +165,8 @@ int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node)
                        bt_list_for_each_entry(iter, &node->u.field_class_declarator.u.nested.length,
                                                siblings) {
                                iter->parent = node;
-                               ret = ctf_visitor_parent_links(depth + 1, iter);
+                               ret = ctf_visitor_parent_links(depth + 1, iter,
+                                       log_level);
                                if (ret)
                                        return ret;
                        }
@@ -164,7 +174,8 @@ int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node)
                if (node->u.field_class_declarator.bitfield_len) {
                        node->u.field_class_declarator.bitfield_len = node;
                        ret = ctf_visitor_parent_links(depth + 1,
-                               node->u.field_class_declarator.bitfield_len);
+                               node->u.field_class_declarator.bitfield_len,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -180,7 +191,8 @@ int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node)
        return 0;
 }
 
-int ctf_visitor_parent_links(int depth, struct ctf_node *node)
+int ctf_visitor_parent_links(int depth, struct ctf_node *node,
+               bt_logging_level log_level)
 {
        int ret = 0;
        struct ctf_node *iter;
@@ -192,37 +204,43 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_ROOT:
                bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -231,7 +249,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_EVENT:
                bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -239,7 +258,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_STREAM:
                bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -247,7 +267,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_ENV:
                bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -255,7 +276,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_TRACE:
                bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -263,7 +285,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_CLOCK:
                bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -271,7 +294,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_CALLSITE:
                bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -281,30 +305,35 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
                depth++;
                bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                depth--;
                break;
        case NODE_UNARY_EXPRESSION:
-               return ctf_visitor_unary_expression(depth, node);
+               return ctf_visitor_unary_expression(depth, node, log_level);
 
        case NODE_TYPEDEF:
                depth++;
                node->u.field_class_def.field_class_specifier_list->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_def.field_class_specifier_list);
+               ret = ctf_visitor_parent_links(depth + 1,
+                       node->u.field_class_def.field_class_specifier_list,
+                       log_level);
                if (ret)
                        return ret;
                bt_list_for_each_entry(iter, &node->u.field_class_def.field_class_declarators, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -313,12 +342,15 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_TYPEALIAS_TARGET:
                depth++;
                node->u.field_class_alias_target.field_class_specifier_list->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias_target.field_class_specifier_list);
+               ret = ctf_visitor_parent_links(depth + 1,
+                       node->u.field_class_alias_target.field_class_specifier_list,
+                       log_level);
                if (ret)
                        return ret;
                bt_list_for_each_entry(iter, &node->u.field_class_alias_target.field_class_declarators, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -327,12 +359,15 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_TYPEALIAS_ALIAS:
                depth++;
                node->u.field_class_alias_name.field_class_specifier_list->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias_name.field_class_specifier_list);
+               ret = ctf_visitor_parent_links(depth + 1,
+                       node->u.field_class_alias_name.field_class_specifier_list,
+                       log_level);
                if (ret)
                        return ret;
                bt_list_for_each_entry(iter, &node->u.field_class_alias_name.field_class_declarators, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -340,11 +375,13 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
                break;
        case NODE_TYPEALIAS:
                node->u.field_class_alias.target->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.target);
+               ret = ctf_visitor_parent_links(depth + 1,
+                       node->u.field_class_alias.target, log_level);
                if (ret)
                        return ret;
                node->u.field_class_alias.alias->parent = node;
-               ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.alias);
+               ret = ctf_visitor_parent_links(depth + 1,
+                       node->u.field_class_alias.alias, log_level);
                if (ret)
                        return ret;
                break;
@@ -352,21 +389,23 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_TYPE_SPECIFIER_LIST:
                bt_list_for_each_entry(iter, &node->u.field_class_specifier_list.head, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                break;
 
        case NODE_TYPE_SPECIFIER:
-               ret = ctf_visitor_type_specifier(depth, node);
+               ret = ctf_visitor_type_specifier(depth, node, log_level);
                if (ret)
                        return ret;
                break;
        case NODE_POINTER:
                break;
        case NODE_TYPE_DECLARATOR:
-               ret = ctf_visitor_field_class_declarator(depth, node);
+               ret = ctf_visitor_field_class_declarator(depth, node,
+                       log_level);
                if (ret)
                        return ret;
                break;
@@ -374,7 +413,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_FLOATING_POINT:
                bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -382,7 +422,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_INTEGER:
                bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -390,7 +431,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_STRING:
                bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -398,7 +440,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_ENUMERATOR:
                bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -406,14 +449,16 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_ENUM:
                depth++;
                if (node->u._enum.container_field_class) {
-                       ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_field_class);
+                       ret = ctf_visitor_parent_links(depth + 1,
+                               node->u._enum.container_field_class, log_level);
                        if (ret)
                                return ret;
                }
 
                bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -422,12 +467,14 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
                node->u.struct_or_variant_declaration.field_class_specifier_list->parent = node;
                ret = ctf_visitor_parent_links(depth + 1,
-                       node->u.struct_or_variant_declaration.field_class_specifier_list);
+                       node->u.struct_or_variant_declaration.field_class_specifier_list,
+                       log_level);
                if (ret)
                        return ret;
                bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -435,7 +482,8 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_VARIANT:
                bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
@@ -443,14 +491,16 @@ int ctf_visitor_parent_links(int depth, struct ctf_node *node)
        case NODE_STRUCT:
                bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }
                bt_list_for_each_entry(iter, &node->u._struct.min_align,
                                        siblings) {
                        iter->parent = node;
-                       ret = ctf_visitor_parent_links(depth + 1, iter);
+                       ret = ctf_visitor_parent_links(depth + 1, iter,
+                               log_level);
                        if (ret)
                                return ret;
                }