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

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2010 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Common Trace Format Metadata Parent Link Creator.
 */

#include <errno.h>
#include <glib.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
#define BT_LOG_OUTPUT_LEVEL   (log_cfg->log_level)
#define BT_LOG_TAG            "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"
#include "logging.hpp"
#include "logging/comp-logging.h"

#include "common/assert.h"
#include "common/list.h"
#include "common/macros.h"

#include "ast.hpp"
#include "scanner.hpp"

static int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
                                        struct meta_log_config *log_cfg)
{
    int ret = 0;

    switch (node->u.unary_expression.link) {
    case UNARY_LINK_UNKNOWN:
    case UNARY_DOTLINK:
    case UNARY_ARROWLINK:
    case UNARY_DOTDOTDOT:
        break;
    default:
        _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown expression link type: type=%d\n",
                                          node->u.unary_expression.link);
        return -EINVAL;
    }

    switch (node->u.unary_expression.type) {
    case UNARY_STRING:
    case UNARY_SIGNED_CONSTANT:
    case UNARY_UNSIGNED_CONSTANT:
        break;
    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, log_cfg);
        if (ret)
            return ret;
        break;

    case UNARY_UNKNOWN:
    default:
        _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown expression link type: type=%d\n",
                                          node->u.unary_expression.link);
        return -EINVAL;
    }
    return 0;
}

static int ctf_visitor_type_specifier(int depth, struct ctf_node *node,
                                      struct meta_log_config *log_cfg)
{
    int ret;

    switch (node->u.field_class_specifier.type) {
    case TYPESPEC_VOID:
    case TYPESPEC_CHAR:
    case TYPESPEC_SHORT:
    case TYPESPEC_INT:
    case TYPESPEC_LONG:
    case TYPESPEC_FLOAT:
    case TYPESPEC_DOUBLE:
    case TYPESPEC_SIGNED:
    case TYPESPEC_UNSIGNED:
    case TYPESPEC_BOOL:
    case TYPESPEC_COMPLEX:
    case TYPESPEC_IMAGINARY:
    case TYPESPEC_CONST:
    case TYPESPEC_ID_TYPE:
        break;
    case TYPESPEC_FLOATING_POINT:
    case TYPESPEC_INTEGER:
    case TYPESPEC_STRING:
    case TYPESPEC_STRUCT:
    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, log_cfg);
        if (ret)
            return ret;
        break;

    case TYPESPEC_UNKNOWN:
    default:
        _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown type specifier: type=%d\n",
                                          node->u.field_class_specifier.type);
        return -EINVAL;
    }
    return 0;
}

static int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
                                              struct meta_log_config *log_cfg)
{
    int ret = 0;
    struct ctf_node *iter;

    depth++;

    bt_list_for_each_entry (iter, &node->u.field_class_declarator.pointers, siblings) {
        iter->parent = node;
        ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
        if (ret)
            return ret;
    }

    switch (node->u.field_class_declarator.type) {
    case TYPEDEC_ID:
        break;
    case TYPEDEC_NESTED:
        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, log_cfg);
            if (ret)
                return ret;
        }
        if (!node->u.field_class_declarator.u.nested.abstract_array) {
            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, log_cfg);
                if (ret)
                    return ret;
            }
        }
        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,
                                           log_cfg);
            if (ret)
                return ret;
        }
        break;
    case TYPEDEC_UNKNOWN:
    default:
        _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown type declarator: type=%d\n",
                                          node->u.field_class_declarator.type);
        return -EINVAL;
    }
    depth--;
    return 0;
}

int ctf_visitor_parent_links(int depth, struct ctf_node *node, struct meta_log_config *log_cfg)
{
    int ret = 0;
    struct ctf_node *iter;

    if (node->visited)
        return 0;

    switch (node->type) {
    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, log_cfg);
            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, log_cfg);
            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, log_cfg);
            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, log_cfg);
            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, log_cfg);
            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, log_cfg);
            if (ret)
                return ret;
        }
        break;

    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;

    case NODE_CTF_EXPRESSION:
        depth++;
        bt_list_for_each_entry (iter, &node->u.ctf_expression.left, siblings) {
            iter->parent = node;
            ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
            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, log_cfg);
            if (ret)
                return ret;
        }
        depth--;
        break;
    case NODE_UNARY_EXPRESSION:
        return ctf_visitor_unary_expression(depth, node, log_cfg);

    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, log_cfg);
        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, log_cfg);
            if (ret)
                return ret;
        }
        depth--;
        break;
    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, log_cfg);
        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, log_cfg);
            if (ret)
                return ret;
        }
        depth--;
        break;
    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, log_cfg);
        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, log_cfg);
            if (ret)
                return ret;
        }
        depth--;
        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, log_cfg);
        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, log_cfg);
        if (ret)
            return ret;
        break;

    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, log_cfg);
            if (ret)
                return ret;
        }
        break;

    case NODE_TYPE_SPECIFIER:
        ret = ctf_visitor_type_specifier(depth, node, log_cfg);
        if (ret)
            return ret;
        break;
    case NODE_POINTER:
        break;
    case NODE_TYPE_DECLARATOR:
        ret = ctf_visitor_field_class_declarator(depth, node, log_cfg);
        if (ret)
            return ret;
        break;

    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    case NODE_ENUM:
        depth++;
        if (node->u._enum.container_field_class) {
            ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_field_class, log_cfg);
            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, log_cfg);
            if (ret)
                return ret;
        }
        depth--;
        break;
    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, log_cfg);
        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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            if (ret)
                return ret;
        }
        break;
    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, log_cfg);
            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, log_cfg);
            if (ret)
                return ret;
        }
        break;

    case NODE_UNKNOWN:
    default:
        _BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown node type: type=%d\n", node->type);
        return -EINVAL;
    }
    return ret;
}
Commit	Line	Data
e98a2d6e	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
e98a2d6e	3	*
0235b0db	4	* Copyright 2010 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
e98a2d6e	5	*
0235b0db	6	* Common Trace Format Metadata Parent Link Creator.
e98a2d6e PP	7	*/
e98a2d6e PP	8
c802cacb SM	9	#include <errno.h>
	10	#include <glib.h>
	11	#include <inttypes.h>
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <string.h>
	15	#include <unistd.h>
	16
f7b785ac	17	#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
4164020e SM	18	#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
4164020e SM	19	#define BT_LOG_TAG "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"
c802cacb	20	#include "logging.hpp"
d9c39b0a	21	#include "logging/comp-logging.h"
6fe1fe62	22
578e048b	23	#include "common/assert.h"
578e048b	24	#include "common/list.h"
c802cacb SM	25	#include "common/macros.h"
c802cacb SM	26
087cd0f5	27	#include "ast.hpp"
c802cacb	28	#include "scanner.hpp"
e98a2d6e	29
4164020e SM	30	static int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
4164020e SM	31	struct meta_log_config *log_cfg)
e98a2d6e	32	{
4164020e	33	int ret = 0;
e98a2d6e	34
4164020e SM	35	switch (node->u.unary_expression.link) {
	36	case UNARY_LINK_UNKNOWN:
	37	case UNARY_DOTLINK:
	38	case UNARY_ARROWLINK:
	39	case UNARY_DOTDOTDOT:
	40	break;
	41	default:
	42	_BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown expression link type: type=%d\n",
	43	node->u.unary_expression.link);
	44	return -EINVAL;
	45	}
e98a2d6e	46
4164020e SM	47	switch (node->u.unary_expression.type) {
	48	case UNARY_STRING:
	49	case UNARY_SIGNED_CONSTANT:
	50	case UNARY_UNSIGNED_CONSTANT:
	51	break;
	52	case UNARY_SBRAC:
	53	node->u.unary_expression.u.sbrac_exp->parent = node;
	54	ret =
	55	ctf_visitor_unary_expression(depth + 1, node->u.unary_expression.u.sbrac_exp, log_cfg);
	56	if (ret)
	57	return ret;
	58	break;
e98a2d6e	59
4164020e SM	60	case UNARY_UNKNOWN:
	61	default:
	62	_BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown expression link type: type=%d\n",
	63	node->u.unary_expression.link);
	64	return -EINVAL;
	65	}
	66	return 0;
e98a2d6e PP	67	}
e98a2d6e PP	68
4164020e SM	69	static int ctf_visitor_type_specifier(int depth, struct ctf_node *node,
4164020e SM	70	struct meta_log_config *log_cfg)
e98a2d6e	71	{
4164020e	72	int ret;
e98a2d6e	73
4164020e SM	74	switch (node->u.field_class_specifier.type) {
	75	case TYPESPEC_VOID:
	76	case TYPESPEC_CHAR:
	77	case TYPESPEC_SHORT:
	78	case TYPESPEC_INT:
	79	case TYPESPEC_LONG:
	80	case TYPESPEC_FLOAT:
	81	case TYPESPEC_DOUBLE:
	82	case TYPESPEC_SIGNED:
	83	case TYPESPEC_UNSIGNED:
	84	case TYPESPEC_BOOL:
	85	case TYPESPEC_COMPLEX:
	86	case TYPESPEC_IMAGINARY:
	87	case TYPESPEC_CONST:
	88	case TYPESPEC_ID_TYPE:
	89	break;
	90	case TYPESPEC_FLOATING_POINT:
	91	case TYPESPEC_INTEGER:
	92	case TYPESPEC_STRING:
	93	case TYPESPEC_STRUCT:
	94	case TYPESPEC_VARIANT:
	95	case TYPESPEC_ENUM:
	96	node->u.field_class_specifier.node->parent = node;
	97	ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_specifier.node, log_cfg);
	98	if (ret)
	99	return ret;
	100	break;
e98a2d6e	101
4164020e SM	102	case TYPESPEC_UNKNOWN:
	103	default:
	104	_BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown type specifier: type=%d\n",
	105	node->u.field_class_specifier.type);
	106	return -EINVAL;
	107	}
	108	return 0;
e98a2d6e PP	109	}
e98a2d6e PP	110
4164020e SM	111	static int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
4164020e SM	112	struct meta_log_config *log_cfg)
e98a2d6e	113	{
4164020e SM	114	int ret = 0;
4164020e SM	115	struct ctf_node *iter;
e98a2d6e	116
4164020e	117	depth++;
e98a2d6e	118
4164020e SM	119	bt_list_for_each_entry (iter, &node->u.field_class_declarator.pointers, siblings) {
	120	iter->parent = node;
	121	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	122	if (ret)
	123	return ret;
	124	}
e98a2d6e	125
4164020e SM	126	switch (node->u.field_class_declarator.type) {
	127	case TYPEDEC_ID:
	128	break;
	129	case TYPEDEC_NESTED:
	130	if (node->u.field_class_declarator.u.nested.field_class_declarator) {
	131	node->u.field_class_declarator.u.nested.field_class_declarator->parent = node;
	132	ret = ctf_visitor_parent_links(
	133	depth + 1, node->u.field_class_declarator.u.nested.field_class_declarator, log_cfg);
	134	if (ret)
	135	return ret;
	136	}
	137	if (!node->u.field_class_declarator.u.nested.abstract_array) {
	138	bt_list_for_each_entry (iter, &node->u.field_class_declarator.u.nested.length,
	139	siblings) {
	140	iter->parent = node;
	141	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	142	if (ret)
	143	return ret;
	144	}
	145	}
	146	if (node->u.field_class_declarator.bitfield_len) {
	147	node->u.field_class_declarator.bitfield_len = node;
	148	ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_declarator.bitfield_len,
	149	log_cfg);
	150	if (ret)
	151	return ret;
	152	}
	153	break;
	154	case TYPEDEC_UNKNOWN:
	155	default:
	156	_BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown type declarator: type=%d\n",
	157	node->u.field_class_declarator.type);
	158	return -EINVAL;
	159	}
	160	depth--;
	161	return 0;
e98a2d6e PP	162	}
e98a2d6e PP	163
4164020e	164	int ctf_visitor_parent_links(int depth, struct ctf_node node, struct meta_log_config log_cfg)
e98a2d6e	165	{
4164020e SM	166	int ret = 0;
4164020e SM	167	struct ctf_node *iter;
e98a2d6e	168
4164020e SM	169	if (node->visited)
4164020e SM	170	return 0;
e98a2d6e	171
4164020e SM	172	switch (node->type) {
	173	case NODE_ROOT:
	174	bt_list_for_each_entry (iter, &node->u.root.declaration_list, siblings) {
	175	iter->parent = node;
	176	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	177	if (ret)
	178	return ret;
	179	}
	180	bt_list_for_each_entry (iter, &node->u.root.trace, siblings) {
	181	iter->parent = node;
	182	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	183	if (ret)
	184	return ret;
	185	}
	186	bt_list_for_each_entry (iter, &node->u.root.stream, siblings) {
	187	iter->parent = node;
	188	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	189	if (ret)
	190	return ret;
	191	}
	192	bt_list_for_each_entry (iter, &node->u.root.event, siblings) {
	193	iter->parent = node;
	194	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	195	if (ret)
	196	return ret;
	197	}
	198	bt_list_for_each_entry (iter, &node->u.root.clock, siblings) {
	199	iter->parent = node;
	200	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	201	if (ret)
	202	return ret;
	203	}
	204	bt_list_for_each_entry (iter, &node->u.root.callsite, siblings) {
	205	iter->parent = node;
	206	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	207	if (ret)
	208	return ret;
	209	}
	210	break;
e98a2d6e	211
4164020e SM	212	case NODE_EVENT:
	213	bt_list_for_each_entry (iter, &node->u.event.declaration_list, siblings) {
	214	iter->parent = node;
	215	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	216	if (ret)
	217	return ret;
	218	}
	219	break;
	220	case NODE_STREAM:
	221	bt_list_for_each_entry (iter, &node->u.stream.declaration_list, siblings) {
	222	iter->parent = node;
	223	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	224	if (ret)
	225	return ret;
	226	}
	227	break;
	228	case NODE_ENV:
	229	bt_list_for_each_entry (iter, &node->u.env.declaration_list, siblings) {
	230	iter->parent = node;
	231	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	232	if (ret)
	233	return ret;
	234	}
	235	break;
	236	case NODE_TRACE:
	237	bt_list_for_each_entry (iter, &node->u.trace.declaration_list, siblings) {
	238	iter->parent = node;
	239	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	240	if (ret)
	241	return ret;
	242	}
	243	break;
	244	case NODE_CLOCK:
	245	bt_list_for_each_entry (iter, &node->u.clock.declaration_list, siblings) {
	246	iter->parent = node;
	247	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	248	if (ret)
	249	return ret;
	250	}
	251	break;
	252	case NODE_CALLSITE:
	253	bt_list_for_each_entry (iter, &node->u.callsite.declaration_list, siblings) {
	254	iter->parent = node;
	255	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	256	if (ret)
	257	return ret;
	258	}
	259	break;
e98a2d6e	260
4164020e SM	261	case NODE_CTF_EXPRESSION:
	262	depth++;
	263	bt_list_for_each_entry (iter, &node->u.ctf_expression.left, siblings) {
	264	iter->parent = node;
	265	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	266	if (ret)
	267	return ret;
	268	}
	269	bt_list_for_each_entry (iter, &node->u.ctf_expression.right, siblings) {
	270	iter->parent = node;
	271	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	272	if (ret)
	273	return ret;
	274	}
	275	depth--;
	276	break;
	277	case NODE_UNARY_EXPRESSION:
	278	return ctf_visitor_unary_expression(depth, node, log_cfg);
e98a2d6e	279
4164020e SM	280	case NODE_TYPEDEF:
	281	depth++;
	282	node->u.field_class_def.field_class_specifier_list->parent = node;
	283	ret = ctf_visitor_parent_links(depth + 1,
	284	node->u.field_class_def.field_class_specifier_list, log_cfg);
	285	if (ret)
	286	return ret;
	287	bt_list_for_each_entry (iter, &node->u.field_class_def.field_class_declarators, siblings) {
	288	iter->parent = node;
	289	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	290	if (ret)
	291	return ret;
	292	}
	293	depth--;
	294	break;
	295	case NODE_TYPEALIAS_TARGET:
	296	depth++;
	297	node->u.field_class_alias_target.field_class_specifier_list->parent = node;
	298	ret = ctf_visitor_parent_links(
	299	depth + 1, node->u.field_class_alias_target.field_class_specifier_list, log_cfg);
	300	if (ret)
	301	return ret;
	302	bt_list_for_each_entry (iter, &node->u.field_class_alias_target.field_class_declarators,
	303	siblings) {
	304	iter->parent = node;
	305	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	306	if (ret)
	307	return ret;
	308	}
	309	depth--;
	310	break;
	311	case NODE_TYPEALIAS_ALIAS:
	312	depth++;
	313	node->u.field_class_alias_name.field_class_specifier_list->parent = node;
	314	ret = ctf_visitor_parent_links(
	315	depth + 1, node->u.field_class_alias_name.field_class_specifier_list, log_cfg);
	316	if (ret)
	317	return ret;
	318	bt_list_for_each_entry (iter, &node->u.field_class_alias_name.field_class_declarators,
	319	siblings) {
	320	iter->parent = node;
	321	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	322	if (ret)
	323	return ret;
	324	}
	325	depth--;
	326	break;
	327	case NODE_TYPEALIAS:
	328	node->u.field_class_alias.target->parent = node;
	329	ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.target, log_cfg);
	330	if (ret)
	331	return ret;
	332	node->u.field_class_alias.alias->parent = node;
	333	ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.alias, log_cfg);
	334	if (ret)
	335	return ret;
	336	break;
e98a2d6e	337
4164020e SM	338	case NODE_TYPE_SPECIFIER_LIST:
	339	bt_list_for_each_entry (iter, &node->u.field_class_specifier_list.head, siblings) {
	340	iter->parent = node;
	341	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	342	if (ret)
	343	return ret;
	344	}
	345	break;
e98a2d6e	346
4164020e SM	347	case NODE_TYPE_SPECIFIER:
	348	ret = ctf_visitor_type_specifier(depth, node, log_cfg);
	349	if (ret)
	350	return ret;
	351	break;
	352	case NODE_POINTER:
	353	break;
	354	case NODE_TYPE_DECLARATOR:
	355	ret = ctf_visitor_field_class_declarator(depth, node, log_cfg);
	356	if (ret)
	357	return ret;
	358	break;
e98a2d6e	359
4164020e SM	360	case NODE_FLOATING_POINT:
	361	bt_list_for_each_entry (iter, &node->u.floating_point.expressions, siblings) {
	362	iter->parent = node;
	363	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	364	if (ret)
	365	return ret;
	366	}
	367	break;
	368	case NODE_INTEGER:
	369	bt_list_for_each_entry (iter, &node->u.integer.expressions, siblings) {
	370	iter->parent = node;
	371	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	372	if (ret)
	373	return ret;
	374	}
	375	break;
	376	case NODE_STRING:
	377	bt_list_for_each_entry (iter, &node->u.string.expressions, siblings) {
	378	iter->parent = node;
	379	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	380	if (ret)
	381	return ret;
	382	}
	383	break;
	384	case NODE_ENUMERATOR:
	385	bt_list_for_each_entry (iter, &node->u.enumerator.values, siblings) {
	386	iter->parent = node;
	387	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	388	if (ret)
	389	return ret;
	390	}
	391	break;
	392	case NODE_ENUM:
	393	depth++;
	394	if (node->u._enum.container_field_class) {
	395	ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_field_class, log_cfg);
	396	if (ret)
	397	return ret;
	398	}
e98a2d6e	399
4164020e SM	400	bt_list_for_each_entry (iter, &node->u._enum.enumerator_list, siblings) {
	401	iter->parent = node;
	402	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	403	if (ret)
	404	return ret;
	405	}
	406	depth--;
	407	break;
	408	case NODE_STRUCT_OR_VARIANT_DECLARATION:
	409	node->u.struct_or_variant_declaration.field_class_specifier_list->parent = node;
	410	ret = ctf_visitor_parent_links(
	411	depth + 1, node->u.struct_or_variant_declaration.field_class_specifier_list, log_cfg);
	412	if (ret)
	413	return ret;
	414	bt_list_for_each_entry (
	415	iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) {
	416	iter->parent = node;
	417	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	418	if (ret)
	419	return ret;
	420	}
	421	break;
	422	case NODE_VARIANT:
	423	bt_list_for_each_entry (iter, &node->u.variant.declaration_list, siblings) {
	424	iter->parent = node;
	425	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	426	if (ret)
	427	return ret;
	428	}
	429	break;
	430	case NODE_STRUCT:
	431	bt_list_for_each_entry (iter, &node->u._struct.declaration_list, siblings) {
	432	iter->parent = node;
	433	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	434	if (ret)
	435	return ret;
	436	}
	437	bt_list_for_each_entry (iter, &node->u._struct.min_align, siblings) {
	438	iter->parent = node;
	439	ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
	440	if (ret)
	441	return ret;
	442	}
	443	break;
e98a2d6e	444
4164020e SM	445	case NODE_UNKNOWN:
	446	default:
	447	_BT_COMP_LOGE_APPEND_CAUSE_LINENO(node->lineno, "Unknown node type: type=%d\n", node->type);
	448	return -EINVAL;
	449	}
	450	return ret;
e98a2d6e	451	}