403adf82cabc8267aa09458fbd195173894a1e55
[babeltrace.git] / formats / ctf / metadata / ctf-visitor-parent-links.c
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>
27 #include <babeltrace/babeltrace-internal.h>
28 #include <babeltrace/list.h>
29 #include "ctf-scanner.h"
30 #include "ctf-parser.h"
31 #include "ctf-ast.h"
32
33 #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
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 {
84 int ret;
85
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:
98 case TYPESPEC_IMAGINARY:
99 case TYPESPEC_CONST:
100 case TYPESPEC_ID_TYPE:
101 break;
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;
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
131 bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
132 siblings) {
133 iter->parent = node;
134 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
135 if (ret)
136 return ret;
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 }
150 if (!node->u.type_declarator.u.nested.abstract_array) {
151 bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
152 siblings) {
153 iter->parent = node;
154 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
155 if (ret)
156 return ret;
157 }
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:
184 bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
185 iter->parent = node;
186 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
187 if (ret)
188 return ret;
189 }
190 bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
191 iter->parent = node;
192 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
193 if (ret)
194 return ret;
195 }
196 bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
197 iter->parent = node;
198 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
199 if (ret)
200 return ret;
201 }
202 bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
203 iter->parent = node;
204 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
205 if (ret)
206 return ret;
207 }
208 bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
209 iter->parent = node;
210 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
211 if (ret)
212 return ret;
213 }
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 }
220 break;
221
222 case NODE_EVENT:
223 bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
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:
231 bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
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_ENV:
239 bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
240 iter->parent = node;
241 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
242 if (ret)
243 return ret;
244 }
245 break;
246 case NODE_TRACE:
247 bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
248 iter->parent = node;
249 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
250 if (ret)
251 return ret;
252 }
253 break;
254 case NODE_CLOCK:
255 bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
256 iter->parent = node;
257 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
258 if (ret)
259 return ret;
260 }
261 break;
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;
270
271 case NODE_CTF_EXPRESSION:
272 depth++;
273 bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
274 iter->parent = node;
275 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
276 if (ret)
277 return ret;
278 }
279 bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
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++;
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;
296 bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
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++;
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;
310 bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
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++;
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;
324 bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
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
343 case NODE_TYPE_SPECIFIER_LIST:
344 bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
345 iter->parent = node;
346 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
347 if (ret)
348 return ret;
349 }
350 break;
351
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:
366 bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
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:
374 bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
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:
382 bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
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:
390 bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
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:
398 depth++;
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 }
404
405 bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
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:
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;
419 bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
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:
427 bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
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:
435 bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
436 iter->parent = node;
437 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
438 if (ret)
439 return ret;
440 }
441 bt_list_for_each_entry(iter, &node->u._struct.min_align,
442 siblings) {
443 iter->parent = node;
444 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
445 if (ret)
446 return ret;
447 }
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 }
This page took 0.058201 seconds and 3 git commands to generate.