[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_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;

	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(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;
67905e42 MD	72
	73	case UNARY_UNKNOWN:
	74	default:
	75	fprintf(fd, "[error] %s: unknown expression type %d\n", __func__,
	76	(int) node->u.unary_expression.type);
	77	return -EINVAL;
	78	}
	79	return 0;
	80	}
	81
	82	static
	83	int ctf_visitor_type_specifier(FILE fd, int depth, struct ctf_node node)
	84	{
3e11b713 MD	85	int ret;
3e11b713 MD	86
67905e42 MD	87	switch (node->u.type_specifier.type) {
	88	case TYPESPEC_VOID:
	89	case TYPESPEC_CHAR:
	90	case TYPESPEC_SHORT:
	91	case TYPESPEC_INT:
	92	case TYPESPEC_LONG:
	93	case TYPESPEC_FLOAT:
	94	case TYPESPEC_DOUBLE:
	95	case TYPESPEC_SIGNED:
	96	case TYPESPEC_UNSIGNED:
	97	case TYPESPEC_BOOL:
	98	case TYPESPEC_COMPLEX:
3888a159	99	case TYPESPEC_IMAGINARY:
67905e42 MD	100	case TYPESPEC_CONST:
	101	case TYPESPEC_ID_TYPE:
	102	break;
3e11b713 MD	103	case TYPESPEC_FLOATING_POINT:
	104	case TYPESPEC_INTEGER:
	105	case TYPESPEC_STRING:
	106	case TYPESPEC_STRUCT:
	107	case TYPESPEC_VARIANT:
	108	case TYPESPEC_ENUM:
	109	node->u.type_specifier.node->parent = node;
	110	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_specifier.node);
	111	if (ret)
	112	return ret;
	113	break;
67905e42 MD	114
	115	case TYPESPEC_UNKNOWN:
	116	default:
	117	fprintf(fd, "[error] %s: unknown type specifier %d\n", __func__,
	118	(int) node->u.type_specifier.type);
	119	return -EINVAL;
	120	}
	121	return 0;
	122	}
	123
	124	static
	125	int ctf_visitor_type_declarator(FILE fd, int depth, struct ctf_node node)
	126	{
	127	int ret = 0;
	128	struct ctf_node *iter;
	129
	130	depth++;
	131
3122e6f0	132	bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
98df1c9f MD	133	siblings) {
	134	iter->parent = node;
	135	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	136	if (ret)
	137	return ret;
67905e42 MD	138	}
	139
	140	switch (node->u.type_declarator.type) {
	141	case TYPEDEC_ID:
	142	break;
	143	case TYPEDEC_NESTED:
	144	if (node->u.type_declarator.u.nested.type_declarator) {
	145	node->u.type_declarator.u.nested.type_declarator->parent = node;
	146	ret = ctf_visitor_parent_links(fd, depth + 1,
	147	node->u.type_declarator.u.nested.type_declarator);
	148	if (ret)
	149	return ret;
	150	}
7c7835b0	151	if (!node->u.type_declarator.u.nested.abstract_array) {
3122e6f0	152	bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
7c7835b0 MD	153	siblings) {
	154	iter->parent = node;
	155	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	156	if (ret)
	157	return ret;
	158	}
67905e42 MD	159	}
	160	if (node->u.type_declarator.bitfield_len) {
	161	node->u.type_declarator.bitfield_len = node;
	162	ret = ctf_visitor_parent_links(fd, depth + 1,
	163	node->u.type_declarator.bitfield_len);
	164	if (ret)
	165	return ret;
	166	}
	167	break;
	168	case TYPEDEC_UNKNOWN:
	169	default:
	170	fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
	171	(int) node->u.type_declarator.type);
	172	return -EINVAL;
	173	}
	174	depth--;
	175	return 0;
	176	}
	177
	178	int ctf_visitor_parent_links(FILE fd, int depth, struct ctf_node node)
	179	{
	180	int ret = 0;
	181	struct ctf_node *iter;
	182
0c880b0a MD	183	if (node->visited)
	184	return 0;
	185
67905e42 MD	186	switch (node->type) {
67905e42 MD	187	case NODE_ROOT:
3122e6f0	188	bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
67905e42 MD	189	iter->parent = node;
	190	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	191	if (ret)
	192	return ret;
	193	}
3122e6f0	194	bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
67905e42 MD	195	iter->parent = node;
	196	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	197	if (ret)
	198	return ret;
	199	}
3122e6f0	200	bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
67905e42 MD	201	iter->parent = node;
	202	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	203	if (ret)
	204	return ret;
	205	}
3122e6f0	206	bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
67905e42 MD	207	iter->parent = node;
	208	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	209	if (ret)
	210	return ret;
	211	}
3122e6f0	212	bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
73d15916 MD	213	iter->parent = node;
	214	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	215	if (ret)
	216	return ret;
	217	}
f133896d MD	218	bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
	219	iter->parent = node;
	220	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	221	if (ret)
	222	return ret;
	223	}
67905e42 MD	224	break;
	225
	226	case NODE_EVENT:
3122e6f0	227	bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
67905e42 MD	228	iter->parent = node;
	229	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	230	if (ret)
	231	return ret;
	232	}
	233	break;
	234	case NODE_STREAM:
3122e6f0	235	bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
67905e42 MD	236	iter->parent = node;
	237	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	238	if (ret)
	239	return ret;
	240	}
	241	break;
e2c76a4d	242	case NODE_ENV:
3122e6f0	243	bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
e2c76a4d MD	244	iter->parent = node;
	245	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	246	if (ret)
	247	return ret;
	248	}
	249	break;
67905e42	250	case NODE_TRACE:
3122e6f0	251	bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
67905e42 MD	252	iter->parent = node;
	253	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	254	if (ret)
	255	return ret;
	256	}
	257	break;
73d15916	258	case NODE_CLOCK:
3122e6f0	259	bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
73d15916 MD	260	iter->parent = node;
	261	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	262	if (ret)
	263	return ret;
	264	}
	265	break;
f133896d MD	266	case NODE_CALLSITE:
	267	bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
	268	iter->parent = node;
	269	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	270	if (ret)
	271	return ret;
	272	}
	273	break;
67905e42 MD	274
	275	case NODE_CTF_EXPRESSION:
	276	depth++;
3122e6f0	277	bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
67905e42 MD	278	iter->parent = node;
	279	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	280	if (ret)
	281	return ret;
	282	}
3122e6f0	283	bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
67905e42 MD	284	iter->parent = node;
	285	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	286	if (ret)
	287	return ret;
	288	}
	289	depth--;
	290	break;
	291	case NODE_UNARY_EXPRESSION:
	292	return ctf_visitor_unary_expression(fd, depth, node);
	293
	294	case NODE_TYPEDEF:
	295	depth++;
3e11b713 MD	296	node->u._typedef.type_specifier_list->parent = node;
	297	ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
	298	if (ret)
	299	return ret;
3122e6f0	300	bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
67905e42 MD	301	iter->parent = node;
	302	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	303	if (ret)
	304	return ret;
	305	}
	306	depth--;
	307	break;
	308	case NODE_TYPEALIAS_TARGET:
	309	depth++;
3e11b713 MD	310	node->u.typealias_target.type_specifier_list->parent = node;
	311	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
	312	if (ret)
	313	return ret;
3122e6f0	314	bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
67905e42 MD	315	iter->parent = node;
	316	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	317	if (ret)
	318	return ret;
	319	}
	320	depth--;
	321	break;
	322	case NODE_TYPEALIAS_ALIAS:
	323	depth++;
3e11b713 MD	324	node->u.typealias_alias.type_specifier_list->parent = node;
	325	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
	326	if (ret)
	327	return ret;
3122e6f0	328	bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
67905e42 MD	329	iter->parent = node;
	330	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	331	if (ret)
	332	return ret;
	333	}
	334	depth--;
	335	break;
	336	case NODE_TYPEALIAS:
	337	node->u.typealias.target->parent = node;
	338	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
	339	if (ret)
	340	return ret;
	341	node->u.typealias.alias->parent = node;
	342	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
	343	if (ret)
	344	return ret;
	345	break;
	346
3e11b713	347	case NODE_TYPE_SPECIFIER_LIST:
3122e6f0	348	bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
3e11b713 MD	349	iter->parent = node;
	350	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	351	if (ret)
	352	return ret;
	353	}
	354	break;
	355
67905e42 MD	356	case NODE_TYPE_SPECIFIER:
	357	ret = ctf_visitor_type_specifier(fd, depth, node);
	358	if (ret)
	359	return ret;
	360	break;
	361	case NODE_POINTER:
	362	break;
	363	case NODE_TYPE_DECLARATOR:
	364	ret = ctf_visitor_type_declarator(fd, depth, node);
	365	if (ret)
	366	return ret;
	367	break;
	368
	369	case NODE_FLOATING_POINT:
3122e6f0	370	bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
67905e42 MD	371	iter->parent = node;
	372	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	373	if (ret)
	374	return ret;
	375	}
	376	break;
	377	case NODE_INTEGER:
3122e6f0	378	bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
67905e42 MD	379	iter->parent = node;
	380	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	381	if (ret)
	382	return ret;
	383	}
	384	break;
	385	case NODE_STRING:
3122e6f0	386	bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
67905e42 MD	387	iter->parent = node;
	388	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	389	if (ret)
	390	return ret;
	391	}
	392	break;
	393	case NODE_ENUMERATOR:
3122e6f0	394	bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
67905e42 MD	395	iter->parent = node;
	396	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	397	if (ret)
	398	return ret;
	399	}
	400	break;
	401	case NODE_ENUM:
67905e42	402	depth++;
6743829a MD	403	if (node->u._enum.container_type) {
	404	ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
	405	if (ret)
	406	return ret;
	407	}
67905e42	408
3122e6f0	409	bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
67905e42 MD	410	iter->parent = node;
	411	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	412	if (ret)
	413	return ret;
	414	}
	415	depth--;
	416	break;
	417	case NODE_STRUCT_OR_VARIANT_DECLARATION:
3e11b713 MD	418	node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
	419	ret = ctf_visitor_parent_links(fd, depth + 1,
	420	node->u.struct_or_variant_declaration.type_specifier_list);
	421	if (ret)
	422	return ret;
3122e6f0	423	bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
67905e42 MD	424	iter->parent = node;
	425	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	426	if (ret)
	427	return ret;
	428	}
	429	break;
	430	case NODE_VARIANT:
3122e6f0	431	bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
67905e42 MD	432	iter->parent = node;
	433	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	434	if (ret)
	435	return ret;
	436	}
	437	break;
	438	case NODE_STRUCT:
3122e6f0	439	bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
67905e42 MD	440	iter->parent = node;
	441	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	442	if (ret)
	443	return ret;
	444	}
3122e6f0	445	bt_list_for_each_entry(iter, &node->u._struct.min_align,
b7e35bad MD	446	siblings) {
	447	iter->parent = node;
	448	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	449	if (ret)
	450	return ret;
	451	}
67905e42 MD	452	break;
	453
	454	case NODE_UNKNOWN:
	455	default:
	456	fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
	457	(int) node->type);
	458	return -EINVAL;
	459	}
	460	return ret;
	461	}