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 }