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