[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.
 */

#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.
	17	*/
	18
	19	#include <stdio.h>
	20	#include <unistd.h>
	21	#include <string.h>
	22	#include <stdlib.h>
	23	#include <assert.h>
	24	#include <glib.h>
	25	#include <inttypes.h>
	26	#include <errno.h>
70bd0a12	27	#include <babeltrace/babeltrace-internal.h>
67905e42 MD	28	#include <babeltrace/list.h>
	29	#include "ctf-scanner.h"
	30	#include "ctf-parser.h"
	31	#include "ctf-ast.h"
	32
34f7b02c	33	#define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
67905e42 MD	34
	35	static
	36	int ctf_visitor_unary_expression(FILE fd, int depth, struct ctf_node node)
	37	{
	38	int ret = 0;
	39
	40	switch (node->u.unary_expression.link) {
	41	case UNARY_LINK_UNKNOWN:
	42	case UNARY_DOTLINK:
	43	case UNARY_ARROWLINK:
	44	case UNARY_DOTDOTDOT:
	45	break;
	46	default:
	47	fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__,
	48	(int) node->u.unary_expression.link);
	49	return -EINVAL;
	50	}
	51
	52	switch (node->u.unary_expression.type) {
	53	case UNARY_STRING:
	54	case UNARY_SIGNED_CONSTANT:
	55	case UNARY_UNSIGNED_CONSTANT:
	56	break;
	57	case UNARY_SBRAC:
	58	node->u.unary_expression.u.sbrac_exp->parent = node;
	59	ret = ctf_visitor_unary_expression(fd, depth + 1,
	60	node->u.unary_expression.u.sbrac_exp);
	61	if (ret)
	62	return ret;
	63	break;
	64	case UNARY_NESTED:
	65	node->u.unary_expression.u.nested_exp->parent = node;
	66	ret = ctf_visitor_unary_expression(fd, depth + 1,
	67	node->u.unary_expression.u.nested_exp);
	68	if (ret)
	69	return ret;
	70	break;
	71
	72	case UNARY_UNKNOWN:
	73	default:
	74	fprintf(fd, "[error] %s: unknown expression type %d\n", __func__,
	75	(int) node->u.unary_expression.type);
	76	return -EINVAL;
	77	}
	78	return 0;
	79	}
	80
	81	static
	82	int ctf_visitor_type_specifier(FILE fd, int depth, struct ctf_node node)
	83	{
3e11b713 MD	84	int ret;
3e11b713 MD	85
67905e42 MD	86	switch (node->u.type_specifier.type) {
	87	case TYPESPEC_VOID:
	88	case TYPESPEC_CHAR:
	89	case TYPESPEC_SHORT:
	90	case TYPESPEC_INT:
	91	case TYPESPEC_LONG:
	92	case TYPESPEC_FLOAT:
	93	case TYPESPEC_DOUBLE:
	94	case TYPESPEC_SIGNED:
	95	case TYPESPEC_UNSIGNED:
	96	case TYPESPEC_BOOL:
	97	case TYPESPEC_COMPLEX:
3888a159	98	case TYPESPEC_IMAGINARY:
67905e42 MD	99	case TYPESPEC_CONST:
	100	case TYPESPEC_ID_TYPE:
	101	break;
3e11b713 MD	102	case TYPESPEC_FLOATING_POINT:
	103	case TYPESPEC_INTEGER:
	104	case TYPESPEC_STRING:
	105	case TYPESPEC_STRUCT:
	106	case TYPESPEC_VARIANT:
	107	case TYPESPEC_ENUM:
	108	node->u.type_specifier.node->parent = node;
	109	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_specifier.node);
	110	if (ret)
	111	return ret;
	112	break;
67905e42 MD	113
	114	case TYPESPEC_UNKNOWN:
	115	default:
	116	fprintf(fd, "[error] %s: unknown type specifier %d\n", __func__,
	117	(int) node->u.type_specifier.type);
	118	return -EINVAL;
	119	}
	120	return 0;
	121	}
	122
	123	static
	124	int ctf_visitor_type_declarator(FILE fd, int depth, struct ctf_node node)
	125	{
	126	int ret = 0;
	127	struct ctf_node *iter;
	128
	129	depth++;
	130
3122e6f0	131	bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
98df1c9f MD	132	siblings) {
	133	iter->parent = node;
	134	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	135	if (ret)
	136	return ret;
67905e42 MD	137	}
	138
	139	switch (node->u.type_declarator.type) {
	140	case TYPEDEC_ID:
	141	break;
	142	case TYPEDEC_NESTED:
	143	if (node->u.type_declarator.u.nested.type_declarator) {
	144	node->u.type_declarator.u.nested.type_declarator->parent = node;
	145	ret = ctf_visitor_parent_links(fd, depth + 1,
	146	node->u.type_declarator.u.nested.type_declarator);
	147	if (ret)
	148	return ret;
	149	}
7c7835b0	150	if (!node->u.type_declarator.u.nested.abstract_array) {
3122e6f0	151	bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
7c7835b0 MD	152	siblings) {
	153	iter->parent = node;
	154	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	155	if (ret)
	156	return ret;
	157	}
67905e42 MD	158	}
	159	if (node->u.type_declarator.bitfield_len) {
	160	node->u.type_declarator.bitfield_len = node;
	161	ret = ctf_visitor_parent_links(fd, depth + 1,
	162	node->u.type_declarator.bitfield_len);
	163	if (ret)
	164	return ret;
	165	}
	166	break;
	167	case TYPEDEC_UNKNOWN:
	168	default:
	169	fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
	170	(int) node->u.type_declarator.type);
	171	return -EINVAL;
	172	}
	173	depth--;
	174	return 0;
	175	}
	176
	177	int ctf_visitor_parent_links(FILE fd, int depth, struct ctf_node node)
	178	{
	179	int ret = 0;
	180	struct ctf_node *iter;
	181
	182	switch (node->type) {
	183	case NODE_ROOT:
3122e6f0	184	bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
67905e42 MD	185	iter->parent = node;
	186	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	187	if (ret)
	188	return ret;
	189	}
3122e6f0	190	bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
67905e42 MD	191	iter->parent = node;
	192	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	193	if (ret)
	194	return ret;
	195	}
3122e6f0	196	bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
67905e42 MD	197	iter->parent = node;
	198	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	199	if (ret)
	200	return ret;
	201	}
3122e6f0	202	bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
67905e42 MD	203	iter->parent = node;
	204	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	205	if (ret)
	206	return ret;
	207	}
3122e6f0	208	bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
73d15916 MD	209	iter->parent = node;
	210	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	211	if (ret)
	212	return ret;
	213	}
f133896d MD	214	bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
	215	iter->parent = node;
	216	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	217	if (ret)
	218	return ret;
	219	}
67905e42 MD	220	break;
	221
	222	case NODE_EVENT:
3122e6f0	223	bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
67905e42 MD	224	iter->parent = node;
	225	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	226	if (ret)
	227	return ret;
	228	}
	229	break;
	230	case NODE_STREAM:
3122e6f0	231	bt_list_for_each_entry(iter, &node->u.stream.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;
e2c76a4d	238	case NODE_ENV:
3122e6f0	239	bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
e2c76a4d MD	240	iter->parent = node;
	241	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	242	if (ret)
	243	return ret;
	244	}
	245	break;
67905e42	246	case NODE_TRACE:
3122e6f0	247	bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
67905e42 MD	248	iter->parent = node;
	249	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	250	if (ret)
	251	return ret;
	252	}
	253	break;
73d15916	254	case NODE_CLOCK:
3122e6f0	255	bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
73d15916 MD	256	iter->parent = node;
	257	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	258	if (ret)
	259	return ret;
	260	}
	261	break;
f133896d MD	262	case NODE_CALLSITE:
	263	bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
	264	iter->parent = node;
	265	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	266	if (ret)
	267	return ret;
	268	}
	269	break;
67905e42 MD	270
	271	case NODE_CTF_EXPRESSION:
	272	depth++;
3122e6f0	273	bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
67905e42 MD	274	iter->parent = node;
	275	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	276	if (ret)
	277	return ret;
	278	}
3122e6f0	279	bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
67905e42 MD	280	iter->parent = node;
	281	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	282	if (ret)
	283	return ret;
	284	}
	285	depth--;
	286	break;
	287	case NODE_UNARY_EXPRESSION:
	288	return ctf_visitor_unary_expression(fd, depth, node);
	289
	290	case NODE_TYPEDEF:
	291	depth++;
3e11b713 MD	292	node->u._typedef.type_specifier_list->parent = node;
	293	ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
	294	if (ret)
	295	return ret;
3122e6f0	296	bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
67905e42 MD	297	iter->parent = node;
	298	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	299	if (ret)
	300	return ret;
	301	}
	302	depth--;
	303	break;
	304	case NODE_TYPEALIAS_TARGET:
	305	depth++;
3e11b713 MD	306	node->u.typealias_target.type_specifier_list->parent = node;
	307	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
	308	if (ret)
	309	return ret;
3122e6f0	310	bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
67905e42 MD	311	iter->parent = node;
	312	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	313	if (ret)
	314	return ret;
	315	}
	316	depth--;
	317	break;
	318	case NODE_TYPEALIAS_ALIAS:
	319	depth++;
3e11b713 MD	320	node->u.typealias_alias.type_specifier_list->parent = node;
	321	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
	322	if (ret)
	323	return ret;
3122e6f0	324	bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
67905e42 MD	325	iter->parent = node;
	326	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	327	if (ret)
	328	return ret;
	329	}
	330	depth--;
	331	break;
	332	case NODE_TYPEALIAS:
	333	node->u.typealias.target->parent = node;
	334	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
	335	if (ret)
	336	return ret;
	337	node->u.typealias.alias->parent = node;
	338	ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
	339	if (ret)
	340	return ret;
	341	break;
	342
3e11b713	343	case NODE_TYPE_SPECIFIER_LIST:
3122e6f0	344	bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
3e11b713 MD	345	iter->parent = node;
	346	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	347	if (ret)
	348	return ret;
	349	}
	350	break;
	351
67905e42 MD	352	case NODE_TYPE_SPECIFIER:
	353	ret = ctf_visitor_type_specifier(fd, depth, node);
	354	if (ret)
	355	return ret;
	356	break;
	357	case NODE_POINTER:
	358	break;
	359	case NODE_TYPE_DECLARATOR:
	360	ret = ctf_visitor_type_declarator(fd, depth, node);
	361	if (ret)
	362	return ret;
	363	break;
	364
	365	case NODE_FLOATING_POINT:
3122e6f0	366	bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
67905e42 MD	367	iter->parent = node;
	368	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	369	if (ret)
	370	return ret;
	371	}
	372	break;
	373	case NODE_INTEGER:
3122e6f0	374	bt_list_for_each_entry(iter, &node->u.integer.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_STRING:
3122e6f0	382	bt_list_for_each_entry(iter, &node->u.string.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_ENUMERATOR:
3122e6f0	390	bt_list_for_each_entry(iter, &node->u.enumerator.values, 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_ENUM:
67905e42	398	depth++;
6743829a MD	399	if (node->u._enum.container_type) {
	400	ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
	401	if (ret)
	402	return ret;
	403	}
67905e42	404
3122e6f0	405	bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
67905e42 MD	406	iter->parent = node;
	407	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	408	if (ret)
	409	return ret;
	410	}
	411	depth--;
	412	break;
	413	case NODE_STRUCT_OR_VARIANT_DECLARATION:
3e11b713 MD	414	node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
	415	ret = ctf_visitor_parent_links(fd, depth + 1,
	416	node->u.struct_or_variant_declaration.type_specifier_list);
	417	if (ret)
	418	return ret;
3122e6f0	419	bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
67905e42 MD	420	iter->parent = node;
	421	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	422	if (ret)
	423	return ret;
	424	}
	425	break;
	426	case NODE_VARIANT:
3122e6f0	427	bt_list_for_each_entry(iter, &node->u.variant.declaration_list, 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_STRUCT:
3122e6f0	435	bt_list_for_each_entry(iter, &node->u._struct.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	}
3122e6f0	441	bt_list_for_each_entry(iter, &node->u._struct.min_align,
b7e35bad MD	442	siblings) {
	443	iter->parent = node;
	444	ret = ctf_visitor_parent_links(fd, depth + 1, iter);
	445	if (ret)
	446	return ret;
	447	}
67905e42 MD	448	break;
	449
	450	case NODE_UNKNOWN:
	451	default:
	452	fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
	453	(int) node->type);
	454	return -EINVAL;
	455	}
	456	return ret;
	457	}