Combine duplicated API/pretty-print timestamp code
[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 break;
215
216 case NODE_EVENT:
217 bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
218 iter->parent = node;
219 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
220 if (ret)
221 return ret;
222 }
223 break;
224 case NODE_STREAM:
225 bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
226 iter->parent = node;
227 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
228 if (ret)
229 return ret;
230 }
231 break;
232 case NODE_ENV:
233 bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
234 iter->parent = node;
235 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
236 if (ret)
237 return ret;
238 }
239 break;
240 case NODE_TRACE:
241 bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
242 iter->parent = node;
243 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
244 if (ret)
245 return ret;
246 }
247 break;
248 case NODE_CLOCK:
249 bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
250 iter->parent = node;
251 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
252 if (ret)
253 return ret;
254 }
255 break;
256
257 case NODE_CTF_EXPRESSION:
258 depth++;
259 bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
260 iter->parent = node;
261 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
262 if (ret)
263 return ret;
264 }
265 bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
266 iter->parent = node;
267 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
268 if (ret)
269 return ret;
270 }
271 depth--;
272 break;
273 case NODE_UNARY_EXPRESSION:
274 return ctf_visitor_unary_expression(fd, depth, node);
275
276 case NODE_TYPEDEF:
277 depth++;
278 node->u._typedef.type_specifier_list->parent = node;
279 ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
280 if (ret)
281 return ret;
282 bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
283 iter->parent = node;
284 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
285 if (ret)
286 return ret;
287 }
288 depth--;
289 break;
290 case NODE_TYPEALIAS_TARGET:
291 depth++;
292 node->u.typealias_target.type_specifier_list->parent = node;
293 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
294 if (ret)
295 return ret;
296 bt_list_for_each_entry(iter, &node->u.typealias_target.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_ALIAS:
305 depth++;
306 node->u.typealias_alias.type_specifier_list->parent = node;
307 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
308 if (ret)
309 return ret;
310 bt_list_for_each_entry(iter, &node->u.typealias_alias.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:
319 node->u.typealias.target->parent = node;
320 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
321 if (ret)
322 return ret;
323 node->u.typealias.alias->parent = node;
324 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
325 if (ret)
326 return ret;
327 break;
328
329 case NODE_TYPE_SPECIFIER_LIST:
330 bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
331 iter->parent = node;
332 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
333 if (ret)
334 return ret;
335 }
336 break;
337
338 case NODE_TYPE_SPECIFIER:
339 ret = ctf_visitor_type_specifier(fd, depth, node);
340 if (ret)
341 return ret;
342 break;
343 case NODE_POINTER:
344 break;
345 case NODE_TYPE_DECLARATOR:
346 ret = ctf_visitor_type_declarator(fd, depth, node);
347 if (ret)
348 return ret;
349 break;
350
351 case NODE_FLOATING_POINT:
352 bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
353 iter->parent = node;
354 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
355 if (ret)
356 return ret;
357 }
358 break;
359 case NODE_INTEGER:
360 bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
361 iter->parent = node;
362 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
363 if (ret)
364 return ret;
365 }
366 break;
367 case NODE_STRING:
368 bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
369 iter->parent = node;
370 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
371 if (ret)
372 return ret;
373 }
374 break;
375 case NODE_ENUMERATOR:
376 bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
377 iter->parent = node;
378 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
379 if (ret)
380 return ret;
381 }
382 break;
383 case NODE_ENUM:
384 depth++;
385 if (node->u._enum.container_type) {
386 ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
387 if (ret)
388 return ret;
389 }
390
391 bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
392 iter->parent = node;
393 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
394 if (ret)
395 return ret;
396 }
397 depth--;
398 break;
399 case NODE_STRUCT_OR_VARIANT_DECLARATION:
400 node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
401 ret = ctf_visitor_parent_links(fd, depth + 1,
402 node->u.struct_or_variant_declaration.type_specifier_list);
403 if (ret)
404 return ret;
405 bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
406 iter->parent = node;
407 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
408 if (ret)
409 return ret;
410 }
411 break;
412 case NODE_VARIANT:
413 bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
414 iter->parent = node;
415 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
416 if (ret)
417 return ret;
418 }
419 break;
420 case NODE_STRUCT:
421 bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
422 iter->parent = node;
423 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
424 if (ret)
425 return ret;
426 }
427 bt_list_for_each_entry(iter, &node->u._struct.min_align,
428 siblings) {
429 iter->parent = node;
430 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
431 if (ret)
432 return ret;
433 }
434 break;
435
436 case NODE_UNKNOWN:
437 default:
438 fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
439 (int) node->type);
440 return -EINVAL;
441 }
442 return ret;
443 }
This page took 0.038425 seconds and 4 git commands to generate.