[babeltrace.git] / src / plugins / ctf / common / src / metadata / tsdl / 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 <unistd.h>

#include "logging.hpp"

#include "common/list.h"

#include "ast.hpp"

static int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
                                        const bt2c::Logger& logger)
{
    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_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno,
                                        "Unknown expression link type: type={}\n",
                                        (int) 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, logger);
        if (ret)
            return ret;
        break;

    case UNARY_UNKNOWN:
    default:
        _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno,
                                        "Unknown expression link type: type={}\n",
                                        (int) node->u.unary_expression.link);
        return -EINVAL;
    }
    return 0;
}

static int ctf_visitor_type_specifier(int depth, struct ctf_node *node, const bt2c::Logger& logger)
{
    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, logger);
        if (ret)
            return ret;
        break;

    case TYPESPEC_UNKNOWN:
    default:
        _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown type specifier: type={}\n",
                                        (int) node->u.field_class_specifier.type);
        return -EINVAL;
    }
    return 0;
}

static int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
                                              const bt2c::Logger& logger)
{
    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, logger);
        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, logger);
            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, logger);
                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,
                                           logger);
            if (ret)
                return ret;
        }
        break;
    case TYPEDEC_UNKNOWN:
    default:
        _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown type declarator: type={}\n",
                                        (int) node->u.field_class_declarator.type);
        return -EINVAL;
    }
    depth--;
    return 0;
}

int ctf_visitor_parent_links(int depth, struct ctf_node *node, const bt2c::Logger& parentLogger)
{
    int ret = 0;
    struct ctf_node *iter;

    if (node->visited)
        return 0;

    bt2c::Logger logger {parentLogger, "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"};

    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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            if (ret)
                return ret;
        }
        depth--;
        break;
    case NODE_UNARY_EXPRESSION:
        return ctf_visitor_unary_expression(depth, node, logger);

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

    case NODE_TYPE_SPECIFIER:
        ret = ctf_visitor_type_specifier(depth, node, logger);
        if (ret)
            return ret;
        break;
    case NODE_POINTER:
        break;
    case NODE_TYPE_DECLARATOR:
        ret = ctf_visitor_field_class_declarator(depth, node, logger);
        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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
            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, logger);
        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, logger);
            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, logger);
            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, logger);
            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, logger);
            if (ret)
                return ret;
        }
        break;

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