[babeltrace.git] / formats / ctf / metadata / ctf-visitor-parent-links.c

/*
 * ctf-visitor-parent-links.c
 *
 * Common Trace Format Metadata Parent Link Creator.
 *
 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <glib.h>
#include <inttypes.h>
#include <errno.h>
#include <babeltrace/babeltrace-internal.h>
#include <babeltrace/list.h>
#include "ctf-scanner.h"
#include "ctf-parser.h"
#include "ctf-ast.h"

#define fprintf_dbg(fd, fmt, args...)	fprintf(fd, "%s: " fmt, __func__, ## args)

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

	switch (node->u.unary_expression.link) {
	case UNARY_LINK_UNKNOWN:
	case UNARY_DOTLINK:
	case UNARY_ARROWLINK:
	case UNARY_DOTDOTDOT:
		break;
	default:
		fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__,
			(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(fd, depth + 1,
			node->u.unary_expression.u.sbrac_exp);
		if (ret)
			return ret;
		break;
	case UNARY_NESTED:
		node->u.unary_expression.u.nested_exp->parent = node;
		ret = ctf_visitor_unary_expression(fd, depth + 1,
			node->u.unary_expression.u.nested_exp);
		if (ret)
			return ret;
		break;

	case UNARY_UNKNOWN:
	default:
		fprintf(fd, "[error] %s: unknown expression type %d\n", __func__,
			(int) node->u.unary_expression.type);
		return -EINVAL;
	}
	return 0;
}

static
int ctf_visitor_type_specifier(FILE *fd, int depth, struct ctf_node *node)
{
	int ret;

	switch (node->u.type_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.type_specifier.node->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_specifier.node);
		if (ret)
			return ret;
		break;

	case TYPESPEC_UNKNOWN:
	default:
		fprintf(fd, "[error] %s: unknown type specifier %d\n", __func__,
			(int) node->u.type_specifier.type);
		return -EINVAL;
	}
	return 0;
}

static
int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node)
{
	int ret = 0;
	struct ctf_node *iter;

	depth++;

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

	switch (node->u.type_declarator.type) {
	case TYPEDEC_ID:
		break;
	case TYPEDEC_NESTED:
		if (node->u.type_declarator.u.nested.type_declarator) {
			node->u.type_declarator.u.nested.type_declarator->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1,
				node->u.type_declarator.u.nested.type_declarator);
			if (ret)
				return ret;
		}
		if (!node->u.type_declarator.u.nested.abstract_array) {
			bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
						siblings) {
				iter->parent = node;
				ret = ctf_visitor_parent_links(fd, depth + 1, iter);
				if (ret)
					return ret;
			}
		}
		if (node->u.type_declarator.bitfield_len) {
			node->u.type_declarator.bitfield_len = node;
			ret = ctf_visitor_parent_links(fd, depth + 1,
				node->u.type_declarator.bitfield_len);
			if (ret)
				return ret;
		}
		break;
	case TYPEDEC_UNKNOWN:
	default:
		fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
			(int) node->u.type_declarator.type);
		return -EINVAL;
	}
	depth--;
	return 0;
}

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

	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(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		depth--;
		break;
	case NODE_UNARY_EXPRESSION:
		return ctf_visitor_unary_expression(fd, depth, node);

	case NODE_TYPEDEF:
		depth++;
		node->u._typedef.type_specifier_list->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
		if (ret)
			return ret;
		bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		depth--;
		break;
	case NODE_TYPEALIAS_TARGET:
		depth++;
		node->u.typealias_target.type_specifier_list->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
		if (ret)
			return ret;
		bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		depth--;
		break;
	case NODE_TYPEALIAS_ALIAS:
		depth++;
		node->u.typealias_alias.type_specifier_list->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
		if (ret)
			return ret;
		bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		depth--;
		break;
	case NODE_TYPEALIAS:
		node->u.typealias.target->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
		if (ret)
			return ret;
		node->u.typealias.alias->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
		if (ret)
			return ret;
		break;

	case NODE_TYPE_SPECIFIER_LIST:
		bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		break;

	case NODE_TYPE_SPECIFIER:
		ret = ctf_visitor_type_specifier(fd, depth, node);
		if (ret)
			return ret;
		break;
	case NODE_POINTER:
		break;
	case NODE_TYPE_DECLARATOR:
		ret = ctf_visitor_type_declarator(fd, depth, node);
		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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		break;
	case NODE_ENUM:
		depth++;
		if (node->u._enum.container_type) {
			ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
			if (ret)
				return ret;
		}

		bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		depth--;
		break;
	case NODE_STRUCT_OR_VARIANT_DECLARATION:
		node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
		ret = ctf_visitor_parent_links(fd, depth + 1,
			node->u.struct_or_variant_declaration.type_specifier_list);
		if (ret)
			return ret;
		bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			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(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		bt_list_for_each_entry(iter, &node->u._struct.min_align,
					siblings) {
			iter->parent = node;
			ret = ctf_visitor_parent_links(fd, depth + 1, iter);
			if (ret)
				return ret;
		}
		break;

	case NODE_UNKNOWN:
	default:
		fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
			(int) node->type);
		return -EINVAL;
	}
	return ret;
}
Commit	Line	Data
67905e42 MD	1	/*
	2	* ctf-visitor-parent-links.c
	3	*
	4	* Common Trace Format Metadata Parent Link Creator.
	5	*
	6	* Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a copy
	9	* of this software and associated documentation files (the "Software"), to deal
	10	* in the Software without restriction, including without limitation the rights
	11	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	12	* copies of the Software, and to permit persons to whom the Software is
	13	* furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
c462e188 MD	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	21	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	22	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	23	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	24	* SOFTWARE.
67905e42 MD	25	*/
	26
	27	#include <stdio.h>
	28	#include <unistd.h>
	29	#include <string.h>
	30	#include <stdlib.h>
	31	#include <assert.h>
	32	#include <glib.h>
	33	#include <inttypes.h>
	34	#include <errno.h>
70bd0a12	35	#include <babeltrace/babeltrace-internal.h>
67905e42 MD	36	#include <babeltrace/list.h>
	37	#include "ctf-scanner.h"
	38	#include "ctf-parser.h"
	39	#include "ctf-ast.h"
	40
34f7b02c	41	#define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
67905e42 MD	42
	43	static
	44	int ctf_visitor_unary_expression(FILE fd, int depth, struct ctf_node node)
	45	{
	46	int ret = 0;
	47
	48	switch (node->u.unary_expression.link) {
	49	case UNARY_LINK_UNKNOWN:
	50	case UNARY_DOTLINK:
	51	case UNARY_ARROWLINK:
	52	case UNARY_DOTDOTDOT:
	53	break;
	54	default:
	55	fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__,
	56	(int) node->u.unary_expression.link);
	57	return -EINVAL;
	58	}
	59
	60	switch (node->u.unary_expression.type) {
	61	case UNARY_STRING:
	62	case UNARY_SIGNED_CONSTANT:
	63	case UNARY_UNSIGNED_CONSTANT:
	64	break;
	65	case UNARY_SBRAC:
	66	node->u.unary_expression.u.sbrac_exp->parent = node;
	67	ret = ctf_visitor_unary_expression(fd, depth + 1,
	68	node->u.unary_expression.u.sbrac_exp);
	69	if (ret)
	70	return ret;
	71	break;
	72	case UNARY_NESTED:
	73	node->u.unary_expression.u.nested_exp->parent = node;
	74	ret = ctf_visitor_unary_expression(fd, depth + 1,
	75	node->u.unary_expression.u.nested_exp);
	76	if (ret)
	77	return ret;
	78	break;
	79
	80	case UNARY_UNKNOWN:
	81	default:
	82	fprintf(fd, "[error] %s: unknown expression type %d\n", __func__,
	83	(int) node->u.unary_expression.type);
	84	return -EINVAL;
	85	}
	86	return 0;
	87	}
	88
	89	static
	90	int ctf_visitor_type_specifier(FILE fd, int depth, struct ctf_node node)
	91	{
3e11b713 MD	92	int ret;
3e11b713 MD	93
67905e42 MD	94	switch (node->u.type_specifier.type) {
	95	case TYPESPEC_VOID:
	96	case TYPESPEC_CHAR:
	97	case TYPESPEC_SHORT:
	98	case TYPESPEC_INT:
	99	case TYPESPEC_LONG:
	100	case TYPESPEC_FLOAT:
	101	case TYPESPEC_DOUBLE:
	102	case TYPESPEC_SIGNED:
	103	case TYPESPEC_UNSIGNED:
	104	case TYPESPEC_BOOL:
	105	case TYPESPEC_COMPLEX:
3888a159	106	case TYPESPEC_IMAGINARY:
67905e42 MD	107	case TYPESPEC_CONST:
	108	case TYPESPEC_ID_TYPE:
	109	break;
3e11b713 MD	110	case TYPESPEC_FLOATING_POINT:
	111	case TYPESPEC_INTEGER:
	112	case TYPESPEC_STRING:
	113	case TYPESPEC_STRUCT:
	114	case TYPESPEC_VARIANT:
	115	case TYPESPEC_ENUM:
	116	node->u.type_specifier.node->parent = node;
	117	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_specifier.node);
	118	if (ret)
	119	return ret;
	120	break;
67905e42 MD	121
	122	case TYPESPEC_UNKNOWN:
	123	default:
	124	fprintf(fd, "[error] %s: unknown type specifier %d\n", __func__,
	125	(int) node->u.type_specifier.type);
	126	return -EINVAL;
	127	}
	128	return 0;
	129	}
	130
	131	static
	132	int ctf_visitor_type_declarator(FILE fd, int depth, struct ctf_node node)
	133	{
	134	int ret = 0;
	135	struct ctf_node *iter;
	136
	137	depth++;
	138
3122e6f0	139	bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
98df1c9f MD	140	siblings) {
	141	iter->parent = node;
	142	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	143	if (ret)
	144	return ret;
67905e42 MD	145	}
	146
	147	switch (node->u.type_declarator.type) {
	148	case TYPEDEC_ID:
	149	break;
	150	case TYPEDEC_NESTED:
	151	if (node->u.type_declarator.u.nested.type_declarator) {
	152	node->u.type_declarator.u.nested.type_declarator->parent = node;
	153	ret = ctf_visitor_parent_links(fd, depth + 1,
	154	node->u.type_declarator.u.nested.type_declarator);
	155	if (ret)
	156	return ret;
	157	}
7c7835b0	158	if (!node->u.type_declarator.u.nested.abstract_array) {
3122e6f0	159	bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
7c7835b0 MD	160	siblings) {
	161	iter->parent = node;
	162	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	163	if (ret)
	164	return ret;
	165	}
67905e42 MD	166	}
	167	if (node->u.type_declarator.bitfield_len) {
	168	node->u.type_declarator.bitfield_len = node;
	169	ret = ctf_visitor_parent_links(fd, depth + 1,
	170	node->u.type_declarator.bitfield_len);
	171	if (ret)
	172	return ret;
	173	}
	174	break;
	175	case TYPEDEC_UNKNOWN:
	176	default:
	177	fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
	178	(int) node->u.type_declarator.type);
	179	return -EINVAL;
	180	}
	181	depth--;
	182	return 0;
	183	}
	184
	185	int ctf_visitor_parent_links(FILE fd, int depth, struct ctf_node node)
	186	{
	187	int ret = 0;
	188	struct ctf_node *iter;
	189
	190	switch (node->type) {
	191	case NODE_ROOT:
3122e6f0	192	bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
67905e42 MD	193	iter->parent = node;
	194	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	195	if (ret)
	196	return ret;
	197	}
3122e6f0	198	bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
67905e42 MD	199	iter->parent = node;
	200	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	201	if (ret)
	202	return ret;
	203	}
3122e6f0	204	bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
67905e42 MD	205	iter->parent = node;
	206	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	207	if (ret)
	208	return ret;
	209	}
3122e6f0	210	bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
67905e42 MD	211	iter->parent = node;
	212	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	213	if (ret)
	214	return ret;
	215	}
3122e6f0	216	bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
73d15916 MD	217	iter->parent = node;
	218	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	219	if (ret)
	220	return ret;
	221	}
f133896d MD	222	bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
	223	iter->parent = node;
	224	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	225	if (ret)
	226	return ret;
	227	}
67905e42 MD	228	break;
	229
	230	case NODE_EVENT:
3122e6f0	231	bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
67905e42 MD	232	iter->parent = node;
	233	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	234	if (ret)
	235	return ret;
	236	}
	237	break;
	238	case NODE_STREAM:
3122e6f0	239	bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
67905e42 MD	240	iter->parent = node;
	241	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	242	if (ret)
	243	return ret;
	244	}
	245	break;
e2c76a4d	246	case NODE_ENV:
3122e6f0	247	bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
e2c76a4d MD	248	iter->parent = node;
	249	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	250	if (ret)
	251	return ret;
	252	}
	253	break;
67905e42	254	case NODE_TRACE:
3122e6f0	255	bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
67905e42 MD	256	iter->parent = node;
	257	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	258	if (ret)
	259	return ret;
	260	}
	261	break;
73d15916	262	case NODE_CLOCK:
3122e6f0	263	bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
73d15916 MD	264	iter->parent = node;
	265	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	266	if (ret)
	267	return ret;
	268	}
	269	break;
f133896d MD	270	case NODE_CALLSITE:
	271	bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
	272	iter->parent = node;
	273	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	274	if (ret)
	275	return ret;
	276	}
	277	break;
67905e42 MD	278
	279	case NODE_CTF_EXPRESSION:
	280	depth++;
3122e6f0	281	bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
67905e42 MD	282	iter->parent = node;
	283	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	284	if (ret)
	285	return ret;
	286	}
3122e6f0	287	bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
67905e42 MD	288	iter->parent = node;
	289	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	290	if (ret)
	291	return ret;
	292	}
	293	depth--;
	294	break;
	295	case NODE_UNARY_EXPRESSION:
	296	return ctf_visitor_unary_expression(fd, depth, node);
	297
	298	case NODE_TYPEDEF:
	299	depth++;
3e11b713 MD	300	node->u._typedef.type_specifier_list->parent = node;
	301	ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
	302	if (ret)
	303	return ret;
3122e6f0	304	bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
67905e42 MD	305	iter->parent = node;
	306	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	307	if (ret)
	308	return ret;
	309	}
	310	depth--;
	311	break;
	312	case NODE_TYPEALIAS_TARGET:
	313	depth++;
3e11b713 MD	314	node->u.typealias_target.type_specifier_list->parent = node;
	315	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
	316	if (ret)
	317	return ret;
3122e6f0	318	bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
67905e42 MD	319	iter->parent = node;
	320	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	321	if (ret)
	322	return ret;
	323	}
	324	depth--;
	325	break;
	326	case NODE_TYPEALIAS_ALIAS:
	327	depth++;
3e11b713 MD	328	node->u.typealias_alias.type_specifier_list->parent = node;
	329	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
	330	if (ret)
	331	return ret;
3122e6f0	332	bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
67905e42 MD	333	iter->parent = node;
	334	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	335	if (ret)
	336	return ret;
	337	}
	338	depth--;
	339	break;
	340	case NODE_TYPEALIAS:
	341	node->u.typealias.target->parent = node;
	342	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
	343	if (ret)
	344	return ret;
	345	node->u.typealias.alias->parent = node;
	346	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
	347	if (ret)
	348	return ret;
	349	break;
	350
3e11b713	351	case NODE_TYPE_SPECIFIER_LIST:
3122e6f0	352	bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
3e11b713 MD	353	iter->parent = node;
	354	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	355	if (ret)
	356	return ret;
	357	}
	358	break;
	359
67905e42 MD	360	case NODE_TYPE_SPECIFIER:
	361	ret = ctf_visitor_type_specifier(fd, depth, node);
	362	if (ret)
	363	return ret;
	364	break;
	365	case NODE_POINTER:
	366	break;
	367	case NODE_TYPE_DECLARATOR:
	368	ret = ctf_visitor_type_declarator(fd, depth, node);
	369	if (ret)
	370	return ret;
	371	break;
	372
	373	case NODE_FLOATING_POINT:
3122e6f0	374	bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
67905e42 MD	375	iter->parent = node;
	376	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	377	if (ret)
	378	return ret;
	379	}
	380	break;
	381	case NODE_INTEGER:
3122e6f0	382	bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
67905e42 MD	383	iter->parent = node;
	384	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	385	if (ret)
	386	return ret;
	387	}
	388	break;
	389	case NODE_STRING:
3122e6f0	390	bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
67905e42 MD	391	iter->parent = node;
	392	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	393	if (ret)
	394	return ret;
	395	}
	396	break;
	397	case NODE_ENUMERATOR:
3122e6f0	398	bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
67905e42 MD	399	iter->parent = node;
	400	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	401	if (ret)
	402	return ret;
	403	}
	404	break;
	405	case NODE_ENUM:
67905e42	406	depth++;
6743829a MD	407	if (node->u._enum.container_type) {
	408	ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
	409	if (ret)
	410	return ret;
	411	}
67905e42	412
3122e6f0	413	bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
67905e42 MD	414	iter->parent = node;
	415	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	416	if (ret)
	417	return ret;
	418	}
	419	depth--;
	420	break;
	421	case NODE_STRUCT_OR_VARIANT_DECLARATION:
3e11b713 MD	422	node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
	423	ret = ctf_visitor_parent_links(fd, depth + 1,
	424	node->u.struct_or_variant_declaration.type_specifier_list);
	425	if (ret)
	426	return ret;
3122e6f0	427	bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
67905e42 MD	428	iter->parent = node;
	429	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	430	if (ret)
	431	return ret;
	432	}
	433	break;
	434	case NODE_VARIANT:
3122e6f0	435	bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
67905e42 MD	436	iter->parent = node;
	437	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	438	if (ret)
	439	return ret;
	440	}
	441	break;
	442	case NODE_STRUCT:
3122e6f0	443	bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
67905e42 MD	444	iter->parent = node;
	445	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	446	if (ret)
	447	return ret;
	448	}
3122e6f0	449	bt_list_for_each_entry(iter, &node->u._struct.min_align,
b7e35bad MD	450	siblings) {
	451	iter->parent = node;
	452	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	453	if (ret)
	454	return ret;
	455	}
67905e42 MD	456	break;
	457
	458	case NODE_UNKNOWN:
	459	default:
	460	fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
	461	(int) node->type);
	462	return -EINVAL;
	463	}
	464	return ret;
	465	}