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