707f03a5c20af4e71fe626985ce68e97b958f9ee
[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/list.h>
28 #include "ctf-scanner.h"
29 #include "ctf-parser.h"
30 #include "ctf-ast.h"
31
32 #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
33
34 static
35 int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node)
36 {
37 int ret = 0;
38
39 switch (node->u.unary_expression.link) {
40 case UNARY_LINK_UNKNOWN:
41 case UNARY_DOTLINK:
42 case UNARY_ARROWLINK:
43 case UNARY_DOTDOTDOT:
44 break;
45 default:
46 fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__,
47 (int) node->u.unary_expression.link);
48 return -EINVAL;
49 }
50
51 switch (node->u.unary_expression.type) {
52 case UNARY_STRING:
53 case UNARY_SIGNED_CONSTANT:
54 case UNARY_UNSIGNED_CONSTANT:
55 break;
56 case UNARY_SBRAC:
57 node->u.unary_expression.u.sbrac_exp->parent = node;
58 ret = ctf_visitor_unary_expression(fd, depth + 1,
59 node->u.unary_expression.u.sbrac_exp);
60 if (ret)
61 return ret;
62 break;
63 case UNARY_NESTED:
64 node->u.unary_expression.u.nested_exp->parent = node;
65 ret = ctf_visitor_unary_expression(fd, depth + 1,
66 node->u.unary_expression.u.nested_exp);
67 if (ret)
68 return ret;
69 break;
70
71 case UNARY_UNKNOWN:
72 default:
73 fprintf(fd, "[error] %s: unknown expression type %d\n", __func__,
74 (int) node->u.unary_expression.type);
75 return -EINVAL;
76 }
77 return 0;
78 }
79
80 static
81 int ctf_visitor_type_specifier(FILE *fd, int depth, struct ctf_node *node)
82 {
83 int ret;
84
85 switch (node->u.type_specifier.type) {
86 case TYPESPEC_VOID:
87 case TYPESPEC_CHAR:
88 case TYPESPEC_SHORT:
89 case TYPESPEC_INT:
90 case TYPESPEC_LONG:
91 case TYPESPEC_FLOAT:
92 case TYPESPEC_DOUBLE:
93 case TYPESPEC_SIGNED:
94 case TYPESPEC_UNSIGNED:
95 case TYPESPEC_BOOL:
96 case TYPESPEC_COMPLEX:
97 case TYPESPEC_IMAGINARY:
98 case TYPESPEC_CONST:
99 case TYPESPEC_ID_TYPE:
100 break;
101 case TYPESPEC_FLOATING_POINT:
102 case TYPESPEC_INTEGER:
103 case TYPESPEC_STRING:
104 case TYPESPEC_STRUCT:
105 case TYPESPEC_VARIANT:
106 case TYPESPEC_ENUM:
107 node->u.type_specifier.node->parent = node;
108 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_specifier.node);
109 if (ret)
110 return ret;
111 break;
112
113 case TYPESPEC_UNKNOWN:
114 default:
115 fprintf(fd, "[error] %s: unknown type specifier %d\n", __func__,
116 (int) node->u.type_specifier.type);
117 return -EINVAL;
118 }
119 return 0;
120 }
121
122 static
123 int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node)
124 {
125 int ret = 0;
126 struct ctf_node *iter;
127
128 depth++;
129
130 if (!cds_list_empty(&node->u.type_declarator.pointers)) {
131 cds_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
140 switch (node->u.type_declarator.type) {
141 case TYPEDEC_ID:
142 break;
143 case TYPEDEC_NESTED:
144 if (node->u.type_declarator.u.nested.type_declarator) {
145 node->u.type_declarator.u.nested.type_declarator->parent = node;
146 ret = ctf_visitor_parent_links(fd, depth + 1,
147 node->u.type_declarator.u.nested.type_declarator);
148 if (ret)
149 return ret;
150 }
151 if (node->u.type_declarator.u.nested.length) {
152 node->u.type_declarator.u.nested.length->parent = node;
153 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_declarator.u.nested.length);
154 if (ret)
155 return ret;
156 }
157 if (node->u.type_declarator.bitfield_len) {
158 node->u.type_declarator.bitfield_len = node;
159 ret = ctf_visitor_parent_links(fd, depth + 1,
160 node->u.type_declarator.bitfield_len);
161 if (ret)
162 return ret;
163 }
164 break;
165 case TYPEDEC_UNKNOWN:
166 default:
167 fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
168 (int) node->u.type_declarator.type);
169 return -EINVAL;
170 }
171 depth--;
172 return 0;
173 }
174
175 int ctf_visitor_parent_links(FILE *fd, int depth, struct ctf_node *node)
176 {
177 int ret = 0;
178 struct ctf_node *iter;
179
180 switch (node->type) {
181 case NODE_ROOT:
182 cds_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
183 iter->parent = node;
184 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
185 if (ret)
186 return ret;
187 }
188 cds_list_for_each_entry(iter, &node->u.root.trace, siblings) {
189 iter->parent = node;
190 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
191 if (ret)
192 return ret;
193 }
194 cds_list_for_each_entry(iter, &node->u.root.stream, siblings) {
195 iter->parent = node;
196 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
197 if (ret)
198 return ret;
199 }
200 cds_list_for_each_entry(iter, &node->u.root.event, siblings) {
201 iter->parent = node;
202 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
203 if (ret)
204 return ret;
205 }
206 break;
207
208 case NODE_EVENT:
209 cds_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
210 iter->parent = node;
211 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
212 if (ret)
213 return ret;
214 }
215 break;
216 case NODE_STREAM:
217 cds_list_for_each_entry(iter, &node->u.stream.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_TRACE:
225 cds_list_for_each_entry(iter, &node->u.trace.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
233 case NODE_CTF_EXPRESSION:
234 depth++;
235 cds_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
236 iter->parent = node;
237 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
238 if (ret)
239 return ret;
240 }
241 cds_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
242 iter->parent = node;
243 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
244 if (ret)
245 return ret;
246 }
247 depth--;
248 break;
249 case NODE_UNARY_EXPRESSION:
250 return ctf_visitor_unary_expression(fd, depth, node);
251
252 case NODE_TYPEDEF:
253 depth++;
254 node->u._typedef.type_specifier_list->parent = node;
255 ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
256 if (ret)
257 return ret;
258 cds_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
259 iter->parent = node;
260 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
261 if (ret)
262 return ret;
263 }
264 depth--;
265 break;
266 case NODE_TYPEALIAS_TARGET:
267 depth++;
268 node->u.typealias_target.type_specifier_list->parent = node;
269 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
270 if (ret)
271 return ret;
272 cds_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
273 iter->parent = node;
274 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
275 if (ret)
276 return ret;
277 }
278 depth--;
279 break;
280 case NODE_TYPEALIAS_ALIAS:
281 depth++;
282 node->u.typealias_alias.type_specifier_list->parent = node;
283 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
284 if (ret)
285 return ret;
286 cds_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
287 iter->parent = node;
288 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
289 if (ret)
290 return ret;
291 }
292 depth--;
293 break;
294 case NODE_TYPEALIAS:
295 node->u.typealias.target->parent = node;
296 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
297 if (ret)
298 return ret;
299 node->u.typealias.alias->parent = node;
300 ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
301 if (ret)
302 return ret;
303 break;
304
305 case NODE_TYPE_SPECIFIER_LIST:
306 cds_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
307 iter->parent = node;
308 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
309 if (ret)
310 return ret;
311 }
312 break;
313
314 case NODE_TYPE_SPECIFIER:
315 ret = ctf_visitor_type_specifier(fd, depth, node);
316 if (ret)
317 return ret;
318 break;
319 case NODE_POINTER:
320 break;
321 case NODE_TYPE_DECLARATOR:
322 ret = ctf_visitor_type_declarator(fd, depth, node);
323 if (ret)
324 return ret;
325 break;
326
327 case NODE_FLOATING_POINT:
328 cds_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
329 iter->parent = node;
330 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
331 if (ret)
332 return ret;
333 }
334 break;
335 case NODE_INTEGER:
336 cds_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
337 iter->parent = node;
338 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
339 if (ret)
340 return ret;
341 }
342 break;
343 case NODE_STRING:
344 cds_list_for_each_entry(iter, &node->u.string.expressions, 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 case NODE_ENUMERATOR:
352 cds_list_for_each_entry(iter, &node->u.enumerator.values, 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_ENUM:
360 depth++;
361 if (node->u._enum.container_type) {
362 ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
363 if (ret)
364 return ret;
365 }
366
367 cds_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
368 iter->parent = node;
369 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
370 if (ret)
371 return ret;
372 }
373 depth--;
374 break;
375 case NODE_STRUCT_OR_VARIANT_DECLARATION:
376 node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
377 ret = ctf_visitor_parent_links(fd, depth + 1,
378 node->u.struct_or_variant_declaration.type_specifier_list);
379 if (ret)
380 return ret;
381 cds_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
382 iter->parent = node;
383 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
384 if (ret)
385 return ret;
386 }
387 break;
388 case NODE_VARIANT:
389 cds_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
390 iter->parent = node;
391 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
392 if (ret)
393 return ret;
394 }
395 break;
396 case NODE_STRUCT:
397 cds_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
398 iter->parent = node;
399 ret = ctf_visitor_parent_links(fd, depth + 1, iter);
400 if (ret)
401 return ret;
402 }
403 break;
404
405 case NODE_UNKNOWN:
406 default:
407 fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
408 (int) node->type);
409 return -EINVAL;
410 }
411 return ret;
412 }
This page took 0.057398 seconds and 3 git commands to generate.