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.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         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         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                 cds_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
 151                                         siblings) {
 152                         iter->parent = node;
 153                         ret = ctf_visitor_parent_links(fd, depth + 1, iter);
 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                 cds_list_for_each_entry(iter, &node->u._struct.min_align,
 404                                         siblings) {
 405                         iter->parent = node;
 406                         ret = ctf_visitor_parent_links(fd, depth + 1, iter);
 407                         if (ret)
 408                                 return ret;
 409                 }
 410                 break;
 411
 412         case NODE_UNKNOWN:
 413         default:
 414                 fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
 415                         (int) node->type);
 416                 return -EINVAL;
 417         }
 418         return ret;
 419 }