[babeltrace.git] / src / plugins / ctf / common / metadata / ast.hpp

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2011-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#ifndef _CTF_AST_H
#define _CTF_AST_H

#include <stdint.h>
#include <stdio.h>
#include <glib.h>
#include "common/list.h"
#include <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include "common/assert.h"

#include "decoder.hpp"
#include "ctf-meta.hpp"

// the parameter name (of the reentrant 'yyparse' function)
// data is a pointer to a 'SParserParam' structure
//#define YYPARSE_PARAM	scanner

struct ctf_node;
struct ctf_parser;
struct ctf_visitor_generate_ir;

#define EINCOMPLETE 1000

#define FOREACH_CTF_NODES(F)                                                                       \
    F(NODE_UNKNOWN)                                                                                \
    F(NODE_ROOT)                                                                                   \
    F(NODE_ERROR)                                                                                  \
    F(NODE_EVENT)                                                                                  \
    F(NODE_STREAM)                                                                                 \
    F(NODE_ENV)                                                                                    \
    F(NODE_TRACE)                                                                                  \
    F(NODE_CLOCK)                                                                                  \
    F(NODE_CALLSITE)                                                                               \
    F(NODE_CTF_EXPRESSION)                                                                         \
    F(NODE_UNARY_EXPRESSION)                                                                       \
    F(NODE_TYPEDEF)                                                                                \
    F(NODE_TYPEALIAS_TARGET)                                                                       \
    F(NODE_TYPEALIAS_ALIAS)                                                                        \
    F(NODE_TYPEALIAS)                                                                              \
    F(NODE_TYPE_SPECIFIER)                                                                         \
    F(NODE_TYPE_SPECIFIER_LIST)                                                                    \
    F(NODE_POINTER)                                                                                \
    F(NODE_TYPE_DECLARATOR)                                                                        \
    F(NODE_FLOATING_POINT)                                                                         \
    F(NODE_INTEGER)                                                                                \
    F(NODE_STRING)                                                                                 \
    F(NODE_ENUMERATOR)                                                                             \
    F(NODE_ENUM)                                                                                   \
    F(NODE_STRUCT_OR_VARIANT_DECLARATION)                                                          \
    F(NODE_VARIANT)                                                                                \
    F(NODE_STRUCT)

enum node_type
{
#define ENTRY(S) S,
    FOREACH_CTF_NODES(ENTRY)
#undef ENTRY
};

enum ctf_unary
{
    UNARY_UNKNOWN = 0,
    UNARY_STRING,
    UNARY_SIGNED_CONSTANT,
    UNARY_UNSIGNED_CONSTANT,
    UNARY_SBRAC,
};

enum ctf_unary_link
{
    UNARY_LINK_UNKNOWN = 0,
    UNARY_DOTLINK,
    UNARY_ARROWLINK,
    UNARY_DOTDOTDOT,
};

enum ctf_typedec
{
    TYPEDEC_UNKNOWN = 0,
    TYPEDEC_ID,     /* identifier */
    TYPEDEC_NESTED, /* (), array or sequence */
};

enum ctf_typespec
{
    TYPESPEC_UNKNOWN = 0,
    TYPESPEC_VOID,
    TYPESPEC_CHAR,
    TYPESPEC_SHORT,
    TYPESPEC_INT,
    TYPESPEC_LONG,
    TYPESPEC_FLOAT,
    TYPESPEC_DOUBLE,
    TYPESPEC_SIGNED,
    TYPESPEC_UNSIGNED,
    TYPESPEC_BOOL,
    TYPESPEC_COMPLEX,
    TYPESPEC_IMAGINARY,
    TYPESPEC_CONST,
    TYPESPEC_ID_TYPE,
    TYPESPEC_FLOATING_POINT,
    TYPESPEC_INTEGER,
    TYPESPEC_STRING,
    TYPESPEC_STRUCT,
    TYPESPEC_VARIANT,
    TYPESPEC_ENUM,
};

struct ctf_node
{
    /*
     * Parent node is only set on demand by specific visitor.
     */
    struct ctf_node *parent;
    struct bt_list_head siblings;
    struct bt_list_head tmp_head;
    unsigned int lineno;
    /*
     * We mark nodes visited in the generate-ir phase (last
     * phase). We only mark the 1-depth level nodes as visited
     * (never the root node, and not their sub-nodes). This allows
     * skipping already visited nodes when doing incremental
     * metadata append.
     */
    int visited;

    enum node_type type;
    union
    {
        struct
        {
        } unknown;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
            struct bt_list_head trace;
            struct bt_list_head env;
            struct bt_list_head stream;
            struct bt_list_head event;
            struct bt_list_head clock;
            struct bt_list_head callsite;
        } root;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
        } event;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
        } stream;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
        } env;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
        } trace;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
        } clock;
        struct
        {
            /*
             * Children nodes are ctf_expression, field_class_def,
             * field_class_alias and field_class_specifier_list.
             */
            struct bt_list_head declaration_list;
        } callsite;
        struct
        {
            struct bt_list_head left;  /* Should be string */
            struct bt_list_head right; /* Unary exp. or type */
        } ctf_expression;
        struct
        {
            ctf_unary type;
            union
            {
                /*
                 * string for identifier, id_type, keywords,
                 * string literals and character constants.
                 */
                char *string;
                int64_t signed_constant;
                uint64_t unsigned_constant;
                struct ctf_node *sbrac_exp;
            } u;
            ctf_unary_link link;
        } unary_expression;
        struct
        {
            struct ctf_node *field_class_specifier_list;
            struct bt_list_head field_class_declarators;
        } field_class_def;
        /* new type is "alias", existing type "target" */
        struct
        {
            struct ctf_node *field_class_specifier_list;
            struct bt_list_head field_class_declarators;
        } field_class_alias_target;
        struct
        {
            struct ctf_node *field_class_specifier_list;
            struct bt_list_head field_class_declarators;
        } field_class_alias_name;
        struct
        {
            struct ctf_node *target;
            struct ctf_node *alias;
        } field_class_alias;
        struct
        {
            ctf_typespec type;
            /* For struct, variant and enum */
            struct ctf_node *node;
            const char *id_type;
        } field_class_specifier;
        struct
        {
            /* list of field_class_specifier */
            struct bt_list_head head;
        } field_class_specifier_list;
        struct
        {
            unsigned int const_qualifier;
        } pointer;
        struct
        {
            struct bt_list_head pointers;
            ctf_typedec type;
            union
            {
                char *id;
                struct
                {
                    /* typedec has no pointer list */
                    struct ctf_node *field_class_declarator;
                    /*
                     * unary expression (value) or
                     * field_class_specifier_list.
                     */
                    struct bt_list_head length;
                    /* for abstract type declarator */
                    unsigned int abstract_array;
                } nested;
            } u;
            struct ctf_node *bitfield_len;
        } field_class_declarator;
        struct
        {
            /* Children nodes are ctf_expression. */
            struct bt_list_head expressions;
        } floating_point;
        struct
        {
            /* Children nodes are ctf_expression. */
            struct bt_list_head expressions;
        } integer;
        struct
        {
            /* Children nodes are ctf_expression. */
            struct bt_list_head expressions;
        } string;
        struct
        {
            char *id;
            /*
             * Range list or single value node. Contains unary
             * expressions.
             */
            struct bt_list_head values;
        } enumerator;
        struct
        {
            char *enum_id;
            /*
             * Either NULL, or points to unary expression or
             * field_class_specifier_list.
             */
            struct ctf_node *container_field_class;
            struct bt_list_head enumerator_list;
            int has_body;
        } _enum;
        struct
        {
            struct ctf_node *field_class_specifier_list;
            struct bt_list_head field_class_declarators;
        } struct_or_variant_declaration;
        struct
        {
            char *name;
            char *choice;
            /*
             * list of field_class_def, field_class_alias and
             * declarations
             */
            struct bt_list_head declaration_list;
            int has_body;
        } variant;
        struct
        {
            char *name;
            /*
             * list of field_class_def, field_class_alias and
             * declarations
             */
            struct bt_list_head declaration_list;
            int has_body;
            struct bt_list_head min_align; /* align() attribute */
        } _struct;
    } u;
};

struct ctf_ast
{
    struct ctf_node root;
};

const char *node_type(struct ctf_node *node);

struct meta_log_config;

BT_HIDDEN
struct ctf_visitor_generate_ir *
ctf_visitor_generate_ir_create(const struct ctf_metadata_decoder_config *config);

void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor);

BT_HIDDEN
bt_trace_class *ctf_visitor_generate_ir_get_ir_trace_class(struct ctf_visitor_generate_ir *visitor);

BT_HIDDEN
struct ctf_trace_class *
ctf_visitor_generate_ir_borrow_ctf_trace_class(struct ctf_visitor_generate_ir *visitor);

BT_HIDDEN
int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
                                       struct ctf_node *node);

BT_HIDDEN
int ctf_visitor_semantic_check(int depth, struct ctf_node *node, struct meta_log_config *log_cfg);

BT_HIDDEN
int ctf_visitor_parent_links(int depth, struct ctf_node *node, struct meta_log_config *log_cfg);

static inline char *ctf_ast_concatenate_unary_strings(struct bt_list_head *head)
{
    int i = 0;
    GString *str;
    struct ctf_node *node;

    str = g_string_new(NULL);
    BT_ASSERT(str);

    bt_list_for_each_entry (node, head, siblings) {
        char *src_string;

        if (node->type != NODE_UNARY_EXPRESSION || node->u.unary_expression.type != UNARY_STRING ||
            !((node->u.unary_expression.link != UNARY_LINK_UNKNOWN) ^ (i == 0))) {
            goto error;
        }

        switch (node->u.unary_expression.link) {
        case UNARY_DOTLINK:
            g_string_append(str, ".");
            break;
        case UNARY_ARROWLINK:
            g_string_append(str, "->");
            break;
        case UNARY_DOTDOTDOT:
            g_string_append(str, "...");
            break;
        default:
            break;
        }

        src_string = node->u.unary_expression.u.string;
        g_string_append(str, src_string);
        i++;
    }

    /* Destroys the container, returns the underlying string */
    return g_string_free(str, FALSE);

error:
    /* This always returns NULL */
    return g_string_free(str, TRUE);
}

static inline int ctf_ast_get_unary_uuid(struct bt_list_head *head, bt_uuid_t uuid, int log_level,
                                         bt_self_component *self_comp)
{
    int i = 0;
    int ret = 0;
    struct ctf_node *node;

    bt_list_for_each_entry (node, head, siblings) {
        int uexpr_type = node->u.unary_expression.type;
        int uexpr_link = node->u.unary_expression.link;
        const char *src_string;

        if (node->type != NODE_UNARY_EXPRESSION || uexpr_type != UNARY_STRING ||
            uexpr_link != UNARY_LINK_UNKNOWN || i != 0) {
            ret = -EINVAL;
            goto end;
        }

        src_string = node->u.unary_expression.u.string;
        ret = bt_uuid_from_str(src_string, uuid);
        if (ret) {
#ifdef BT_COMP_LOG_CUR_LVL
            BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
                                "Cannot parse UUID: uuid=\"%s\"", src_string);
#endif
            goto end;
        }
    }

end:
    return ret;
}

#endif /* _CTF_AST_H */
Commit	Line	Data
e98a2d6e	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
e98a2d6e	3	*
0235b0db	4	* Copyright 2011-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
e98a2d6e PP	5	*/
e98a2d6e PP	6
0235b0db MJ	7	#ifndef _CTF_AST_H
	8	#define _CTF_AST_H
	9
e98a2d6e PP	10	#include <stdint.h>
	11	#include <stdio.h>
	12	#include <glib.h>
578e048b	13	#include "common/list.h"
3fadfbc0	14	#include <babeltrace2/babeltrace.h>
91d81473	15	#include "common/macros.h"
1a6da3f9	16	#include "common/assert.h"
e98a2d6e	17
087cd0f5 SM	18	#include "decoder.hpp"
087cd0f5 SM	19	#include "ctf-meta.hpp"
a2a54545	20
e98a2d6e PP	21	// the parameter name (of the reentrant 'yyparse' function)
	22	// data is a pointer to a 'SParserParam' structure
	23	//#define YYPARSE_PARAM scanner
	24
	25	struct ctf_node;
	26	struct ctf_parser;
1e649dff PP	27	struct ctf_visitor_generate_ir;
1e649dff PP	28
4164020e SM	29	#define EINCOMPLETE 1000
	30
	31	#define FOREACH_CTF_NODES(F) \
	32	F(NODE_UNKNOWN) \
	33	F(NODE_ROOT) \
	34	F(NODE_ERROR) \
	35	F(NODE_EVENT) \
	36	F(NODE_STREAM) \
	37	F(NODE_ENV) \
	38	F(NODE_TRACE) \
	39	F(NODE_CLOCK) \
	40	F(NODE_CALLSITE) \
	41	F(NODE_CTF_EXPRESSION) \
	42	F(NODE_UNARY_EXPRESSION) \
	43	F(NODE_TYPEDEF) \
	44	F(NODE_TYPEALIAS_TARGET) \
	45	F(NODE_TYPEALIAS_ALIAS) \
	46	F(NODE_TYPEALIAS) \
	47	F(NODE_TYPE_SPECIFIER) \
	48	F(NODE_TYPE_SPECIFIER_LIST) \
	49	F(NODE_POINTER) \
	50	F(NODE_TYPE_DECLARATOR) \
	51	F(NODE_FLOATING_POINT) \
	52	F(NODE_INTEGER) \
	53	F(NODE_STRING) \
	54	F(NODE_ENUMERATOR) \
	55	F(NODE_ENUM) \
	56	F(NODE_STRUCT_OR_VARIANT_DECLARATION) \
	57	F(NODE_VARIANT) \
	58	F(NODE_STRUCT)
	59
	60	enum node_type
	61	{
	62	#define ENTRY(S) S,
	63	FOREACH_CTF_NODES(ENTRY)
e98a2d6e	64	#undef ENTRY
087cd0f5 SM	65	};
087cd0f5 SM	66
4164020e SM	67	enum ctf_unary
	68	{
	69	UNARY_UNKNOWN = 0,
	70	UNARY_STRING,
	71	UNARY_SIGNED_CONSTANT,
	72	UNARY_UNSIGNED_CONSTANT,
	73	UNARY_SBRAC,
087cd0f5 SM	74	};
087cd0f5 SM	75
4164020e SM	76	enum ctf_unary_link
	77	{
	78	UNARY_LINK_UNKNOWN = 0,
	79	UNARY_DOTLINK,
	80	UNARY_ARROWLINK,
	81	UNARY_DOTDOTDOT,
087cd0f5 SM	82	};
087cd0f5 SM	83
4164020e SM	84	enum ctf_typedec
	85	{
	86	TYPEDEC_UNKNOWN = 0,
	87	TYPEDEC_ID, /* identifier */
	88	TYPEDEC_NESTED, /* (), array or sequence */
087cd0f5 SM	89	};
087cd0f5 SM	90
4164020e SM	91	enum ctf_typespec
	92	{
	93	TYPESPEC_UNKNOWN = 0,
	94	TYPESPEC_VOID,
	95	TYPESPEC_CHAR,
	96	TYPESPEC_SHORT,
	97	TYPESPEC_INT,
	98	TYPESPEC_LONG,
	99	TYPESPEC_FLOAT,
	100	TYPESPEC_DOUBLE,
	101	TYPESPEC_SIGNED,
	102	TYPESPEC_UNSIGNED,
	103	TYPESPEC_BOOL,
	104	TYPESPEC_COMPLEX,
	105	TYPESPEC_IMAGINARY,
	106	TYPESPEC_CONST,
	107	TYPESPEC_ID_TYPE,
	108	TYPESPEC_FLOATING_POINT,
	109	TYPESPEC_INTEGER,
	110	TYPESPEC_STRING,
	111	TYPESPEC_STRUCT,
	112	TYPESPEC_VARIANT,
	113	TYPESPEC_ENUM,
e98a2d6e PP	114	};
e98a2d6e PP	115
4164020e SM	116	struct ctf_node
	117	{
	118	/*
	119	* Parent node is only set on demand by specific visitor.
	120	*/
	121	struct ctf_node *parent;
	122	struct bt_list_head siblings;
	123	struct bt_list_head tmp_head;
	124	unsigned int lineno;
	125	/*
	126	* We mark nodes visited in the generate-ir phase (last
	127	* phase). We only mark the 1-depth level nodes as visited
	128	* (never the root node, and not their sub-nodes). This allows
	129	* skipping already visited nodes when doing incremental
	130	* metadata append.
	131	*/
	132	int visited;
	133
	134	enum node_type type;
	135	union
	136	{
	137	struct
	138	{
	139	} unknown;
	140	struct
	141	{
	142	/*
	143	* Children nodes are ctf_expression, field_class_def,
	144	* field_class_alias and field_class_specifier_list.
	145	*/
	146	struct bt_list_head declaration_list;
	147	struct bt_list_head trace;
	148	struct bt_list_head env;
	149	struct bt_list_head stream;
	150	struct bt_list_head event;
	151	struct bt_list_head clock;
	152	struct bt_list_head callsite;
	153	} root;
	154	struct
	155	{
	156	/*
	157	* Children nodes are ctf_expression, field_class_def,
	158	* field_class_alias and field_class_specifier_list.
	159	*/
	160	struct bt_list_head declaration_list;
	161	} event;
	162	struct
	163	{
	164	/*
	165	* Children nodes are ctf_expression, field_class_def,
	166	* field_class_alias and field_class_specifier_list.
	167	*/
	168	struct bt_list_head declaration_list;
	169	} stream;
	170	struct
	171	{
	172	/*
	173	* Children nodes are ctf_expression, field_class_def,
	174	* field_class_alias and field_class_specifier_list.
	175	*/
	176	struct bt_list_head declaration_list;
	177	} env;
	178	struct
	179	{
180	/*
181	* Children nodes are ctf_expression, field_class_def,
182	* field_class_alias and field_class_specifier_list.
183	*/
184	struct bt_list_head declaration_list;
185	} trace;
186	struct
187	{
188	/*
189	* Children nodes are ctf_expression, field_class_def,
190	* field_class_alias and field_class_specifier_list.
191	*/
192	struct bt_list_head declaration_list;
193	} clock;
194	struct
195	{
196	/*
197	* Children nodes are ctf_expression, field_class_def,
198	* field_class_alias and field_class_specifier_list.
199	*/
200	struct bt_list_head declaration_list;
201	} callsite;
202	struct
203	{
204	struct bt_list_head left; /* Should be string */
205	struct bt_list_head right; /* Unary exp. or type */
206	} ctf_expression;
207	struct
208	{
209	ctf_unary type;
210	union
211	{
212	/*
213	* string for identifier, id_type, keywords,
214	* string literals and character constants.
215	*/
216	char *string;
217	int64_t signed_constant;
218	uint64_t unsigned_constant;
219	struct ctf_node *sbrac_exp;
220	} u;
221	ctf_unary_link link;
222	} unary_expression;
223	struct
224	{
225	struct ctf_node *field_class_specifier_list;
226	struct bt_list_head field_class_declarators;
227	} field_class_def;
228	/* new type is "alias", existing type "target" */
229	struct
230	{
231	struct ctf_node *field_class_specifier_list;
232	struct bt_list_head field_class_declarators;
233	} field_class_alias_target;
234	struct
235	{
236	struct ctf_node *field_class_specifier_list;
237	struct bt_list_head field_class_declarators;
238	} field_class_alias_name;
239	struct
240	{
241	struct ctf_node *target;
242	struct ctf_node *alias;
243	} field_class_alias;
244	struct
245	{
246	ctf_typespec type;
247	/* For struct, variant and enum */
248	struct ctf_node *node;
249	const char *id_type;
250	} field_class_specifier;
251	struct
252	{
253	/* list of field_class_specifier */
254	struct bt_list_head head;
255	} field_class_specifier_list;
256	struct
257	{
258	unsigned int const_qualifier;
259	} pointer;
260	struct
261	{
262	struct bt_list_head pointers;
263	ctf_typedec type;
264	union
265	{
266	char *id;
267	struct
268	{
269	/* typedec has no pointer list */
270	struct ctf_node *field_class_declarator;
271	/*
272	* unary expression (value) or
273	* field_class_specifier_list.
274	*/
275	struct bt_list_head length;
276	/* for abstract type declarator */
277	unsigned int abstract_array;
278	} nested;
279	} u;
280	struct ctf_node *bitfield_len;
281	} field_class_declarator;
282	struct
283	{
284	/* Children nodes are ctf_expression. */
285	struct bt_list_head expressions;
286	} floating_point;
287	struct
288	{
289	/* Children nodes are ctf_expression. */
290	struct bt_list_head expressions;
291	} integer;
292	struct
293	{
294	/* Children nodes are ctf_expression. */
295	struct bt_list_head expressions;
296	} string;
297	struct
298	{
299	char *id;
300	/*
301	* Range list or single value node. Contains unary
302	* expressions.
303	*/
304	struct bt_list_head values;
305	} enumerator;
306	struct
307	{
308	char *enum_id;
309	/*
310	* Either NULL, or points to unary expression or
311	* field_class_specifier_list.
312	*/
313	struct ctf_node *container_field_class;
314	struct bt_list_head enumerator_list;
315	int has_body;
316	} _enum;
317	struct
318	{
319	struct ctf_node *field_class_specifier_list;
320	struct bt_list_head field_class_declarators;
321	} struct_or_variant_declaration;
322	struct
323	{
324	char *name;
325	char *choice;
326	/*
327	* list of field_class_def, field_class_alias and
328	* declarations
329	*/
330	struct bt_list_head declaration_list;
331	int has_body;
332	} variant;
333	struct
334	{
335	char *name;
336	/*
337	* list of field_class_def, field_class_alias and
338	* declarations
339	*/
340	struct bt_list_head declaration_list;
341	int has_body;
342	struct bt_list_head min_align; /* align() attribute */
343	} _struct;
344	} u;
e98a2d6e PP	345	};
e98a2d6e PP	346
4164020e SM	347	struct ctf_ast
	348	{
	349	struct ctf_node root;
e98a2d6e PP	350	};
	351
	352	const char node_type(struct ctf_node node);
	353
f7b785ac PP	354	struct meta_log_config;
f7b785ac PP	355
1e649dff	356	BT_HIDDEN
4164020e SM	357	struct ctf_visitor_generate_ir *
4164020e SM	358	ctf_visitor_generate_ir_create(const struct ctf_metadata_decoder_config *config);
1e649dff PP	359
1e649dff PP	360	void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor);
e98a2d6e PP	361
e98a2d6e PP	362	BT_HIDDEN
4164020e	363	bt_trace_class ctf_visitor_generate_ir_get_ir_trace_class(struct ctf_visitor_generate_ir visitor);
44c440bc PP	364
44c440bc PP	365	BT_HIDDEN
4164020e SM	366	struct ctf_trace_class *
4164020e SM	367	ctf_visitor_generate_ir_borrow_ctf_trace_class(struct ctf_visitor_generate_ir *visitor);
e98a2d6e PP	368
e98a2d6e PP	369	BT_HIDDEN
1e649dff	370	int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor,
4164020e	371	struct ctf_node *node);
e98a2d6e PP	372
e98a2d6e PP	373	BT_HIDDEN
4164020e	374	int ctf_visitor_semantic_check(int depth, struct ctf_node node, struct meta_log_config log_cfg);
e98a2d6e PP	375
e98a2d6e PP	376	BT_HIDDEN
4164020e	377	int ctf_visitor_parent_links(int depth, struct ctf_node node, struct meta_log_config log_cfg);
e98a2d6e	378
4164020e	379	static inline char ctf_ast_concatenate_unary_strings(struct bt_list_head head)
1a6da3f9	380	{
4164020e SM	381	int i = 0;
	382	GString *str;
	383	struct ctf_node *node;
	384
	385	str = g_string_new(NULL);
	386	BT_ASSERT(str);
	387
	388	bt_list_for_each_entry (node, head, siblings) {
	389	char *src_string;
	390
	391	if (node->type != NODE_UNARY_EXPRESSION \|\| node->u.unary_expression.type != UNARY_STRING \|\|
	392	!((node->u.unary_expression.link != UNARY_LINK_UNKNOWN) ^ (i == 0))) {
	393	goto error;
	394	}
	395
	396	switch (node->u.unary_expression.link) {
	397	case UNARY_DOTLINK:
	398	g_string_append(str, ".");
	399	break;
	400	case UNARY_ARROWLINK:
	401	g_string_append(str, "->");
	402	break;
	403	case UNARY_DOTDOTDOT:
	404	g_string_append(str, "...");
	405	break;
	406	default:
	407	break;
	408	}
	409
	410	src_string = node->u.unary_expression.u.string;
	411	g_string_append(str, src_string);
	412	i++;
	413	}
	414
	415	/* Destroys the container, returns the underlying string */
	416	return g_string_free(str, FALSE);
1a6da3f9 PP	417
1a6da3f9 PP	418	error:
4164020e SM	419	/* This always returns NULL */
4164020e SM	420	return g_string_free(str, TRUE);
1a6da3f9 PP	421	}
1a6da3f9 PP	422
4164020e SM	423	static inline int ctf_ast_get_unary_uuid(struct bt_list_head *head, bt_uuid_t uuid, int log_level,
4164020e SM	424	bt_self_component *self_comp)
1a6da3f9	425	{
4164020e SM	426	int i = 0;
	427	int ret = 0;
	428	struct ctf_node *node;
	429
	430	bt_list_for_each_entry (node, head, siblings) {
	431	int uexpr_type = node->u.unary_expression.type;
	432	int uexpr_link = node->u.unary_expression.link;
	433	const char *src_string;
	434
	435	if (node->type != NODE_UNARY_EXPRESSION \|\| uexpr_type != UNARY_STRING \|\|
	436	uexpr_link != UNARY_LINK_UNKNOWN \|\| i != 0) {
	437	ret = -EINVAL;
	438	goto end;
	439	}
	440
	441	src_string = node->u.unary_expression.u.string;
	442	ret = bt_uuid_from_str(src_string, uuid);
	443	if (ret) {
1a6da3f9	444	#ifdef BT_COMP_LOG_CUR_LVL
4164020e SM	445	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
4164020e SM	446	"Cannot parse UUID: uuid=\"%s\"", src_string);
1a6da3f9	447	#endif
4164020e SM	448	goto end;
	449	}
	450	}
1a6da3f9 PP	451
1a6da3f9 PP	452	end:
4164020e	453	return ret;
1a6da3f9 PP	454	}
1a6da3f9 PP	455
e98a2d6e	456	#endif /* _CTF_AST_H */