src/plugins/ctf/common/src/metadata/tsdl/visitor-parent-links.cpp

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2010 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * Common Trace Format Metadata Parent Link Creator.
   7  */
   8
   9 #include <errno.h>
  10 #include <unistd.h>
  11
  12 #include "logging.hpp"
  13
  14 #include "common/list.h"
  15
  16 #include "ast.hpp"
  17
  18 static int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
  19                                         const bt2c::Logger& logger)
  20 {
  21     int ret = 0;
  22
  23     switch (node->u.unary_expression.link) {
  24     case UNARY_LINK_UNKNOWN:
  25     case UNARY_DOTLINK:
  26     case UNARY_ARROWLINK:
  27     case UNARY_DOTDOTDOT:
  28         break;
  29     default:
  30         _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno,
  31                                         "Unknown expression link type: type={}\n",
  32                                         (int) node->u.unary_expression.link);
  33         return -EINVAL;
  34     }
  35
  36     switch (node->u.unary_expression.type) {
  37     case UNARY_STRING:
  38     case UNARY_SIGNED_CONSTANT:
  39     case UNARY_UNSIGNED_CONSTANT:
  40         break;
  41     case UNARY_SBRAC:
  42         node->u.unary_expression.u.sbrac_exp->parent = node;
  43         ret = ctf_visitor_unary_expression(depth + 1, node->u.unary_expression.u.sbrac_exp, logger);
  44         if (ret)
  45             return ret;
  46         break;
  47
  48     case UNARY_UNKNOWN:
  49     default:
  50         _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno,
  51                                         "Unknown expression link type: type={}\n",
  52                                         (int) node->u.unary_expression.link);
  53         return -EINVAL;
  54     }
  55     return 0;
  56 }
  57
  58 static int ctf_visitor_type_specifier(int depth, struct ctf_node *node, const bt2c::Logger& logger)
  59 {
  60     int ret;
  61
  62     switch (node->u.field_class_specifier.type) {
  63     case TYPESPEC_VOID:
  64     case TYPESPEC_CHAR:
  65     case TYPESPEC_SHORT:
  66     case TYPESPEC_INT:
  67     case TYPESPEC_LONG:
  68     case TYPESPEC_FLOAT:
  69     case TYPESPEC_DOUBLE:
  70     case TYPESPEC_SIGNED:
  71     case TYPESPEC_UNSIGNED:
  72     case TYPESPEC_BOOL:
  73     case TYPESPEC_COMPLEX:
  74     case TYPESPEC_IMAGINARY:
  75     case TYPESPEC_CONST:
  76     case TYPESPEC_ID_TYPE:
  77         break;
  78     case TYPESPEC_FLOATING_POINT:
  79     case TYPESPEC_INTEGER:
  80     case TYPESPEC_STRING:
  81     case TYPESPEC_STRUCT:
  82     case TYPESPEC_VARIANT:
  83     case TYPESPEC_ENUM:
  84         node->u.field_class_specifier.node->parent = node;
  85         ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_specifier.node, logger);
  86         if (ret)
  87             return ret;
  88         break;
  89
  90     case TYPESPEC_UNKNOWN:
  91     default:
  92         _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown type specifier: type={}\n",
  93                                         (int) node->u.field_class_specifier.type);
  94         return -EINVAL;
  95     }
  96     return 0;
  97 }
  98
  99 static int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
 100                                               const bt2c::Logger& logger)
 101 {
 102     int ret = 0;
 103     struct ctf_node *iter;
 104
 105     depth++;
 106
 107     bt_list_for_each_entry (iter, &node->u.field_class_declarator.pointers, siblings) {
 108         iter->parent = node;
 109         ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 110         if (ret)
 111             return ret;
 112     }
 113
 114     switch (node->u.field_class_declarator.type) {
 115     case TYPEDEC_ID:
 116         break;
 117     case TYPEDEC_NESTED:
 118         if (node->u.field_class_declarator.u.nested.field_class_declarator) {
 119             node->u.field_class_declarator.u.nested.field_class_declarator->parent = node;
 120             ret = ctf_visitor_parent_links(
 121                 depth + 1, node->u.field_class_declarator.u.nested.field_class_declarator, logger);
 122             if (ret)
 123                 return ret;
 124         }
 125         if (!node->u.field_class_declarator.u.nested.abstract_array) {
 126             bt_list_for_each_entry (iter, &node->u.field_class_declarator.u.nested.length,
 127                                     siblings) {
 128                 iter->parent = node;
 129                 ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 130                 if (ret)
 131                     return ret;
 132             }
 133         }
 134         if (node->u.field_class_declarator.bitfield_len) {
 135             node->u.field_class_declarator.bitfield_len = node;
 136             ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_declarator.bitfield_len,
 137                                            logger);
 138             if (ret)
 139                 return ret;
 140         }
 141         break;
 142     case TYPEDEC_UNKNOWN:
 143     default:
 144         _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown type declarator: type={}\n",
 145                                         (int) node->u.field_class_declarator.type);
 146         return -EINVAL;
 147     }
 148     depth--;
 149     return 0;
 150 }
 151
 152 int ctf_visitor_parent_links(int depth, struct ctf_node *node, const bt2c::Logger& parentLogger)
 153 {
 154     int ret = 0;
 155     struct ctf_node *iter;
 156
 157     if (node->visited)
 158         return 0;
 159
 160     bt2c::Logger logger {parentLogger, "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"};
 161
 162     switch (node->type) {
 163     case NODE_ROOT:
 164         bt_list_for_each_entry (iter, &node->u.root.declaration_list, siblings) {
 165             iter->parent = node;
 166             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 167             if (ret)
 168                 return ret;
 169         }
 170         bt_list_for_each_entry (iter, &node->u.root.trace, siblings) {
 171             iter->parent = node;
 172             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 173             if (ret)
 174                 return ret;
 175         }
 176         bt_list_for_each_entry (iter, &node->u.root.stream, siblings) {
 177             iter->parent = node;
 178             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 179             if (ret)
 180                 return ret;
 181         }
 182         bt_list_for_each_entry (iter, &node->u.root.event, siblings) {
 183             iter->parent = node;
 184             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 185             if (ret)
 186                 return ret;
 187         }
 188         bt_list_for_each_entry (iter, &node->u.root.clock, siblings) {
 189             iter->parent = node;
 190             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 191             if (ret)
 192                 return ret;
 193         }
 194         bt_list_for_each_entry (iter, &node->u.root.callsite, siblings) {
 195             iter->parent = node;
 196             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 197             if (ret)
 198                 return ret;
 199         }
 200         break;
 201
 202     case NODE_EVENT:
 203         bt_list_for_each_entry (iter, &node->u.event.declaration_list, siblings) {
 204             iter->parent = node;
 205             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 206             if (ret)
 207                 return ret;
 208         }
 209         break;
 210     case NODE_STREAM:
 211         bt_list_for_each_entry (iter, &node->u.stream.declaration_list, siblings) {
 212             iter->parent = node;
 213             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 214             if (ret)
 215                 return ret;
 216         }
 217         break;
 218     case NODE_ENV:
 219         bt_list_for_each_entry (iter, &node->u.env.declaration_list, siblings) {
 220             iter->parent = node;
 221             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 222             if (ret)
 223                 return ret;
 224         }
 225         break;
 226     case NODE_TRACE:
 227         bt_list_for_each_entry (iter, &node->u.trace.declaration_list, siblings) {
 228             iter->parent = node;
 229             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 230             if (ret)
 231                 return ret;
 232         }
 233         break;
 234     case NODE_CLOCK:
 235         bt_list_for_each_entry (iter, &node->u.clock.declaration_list, siblings) {
 236             iter->parent = node;
 237             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 238             if (ret)
 239                 return ret;
 240         }
 241         break;
 242     case NODE_CALLSITE:
 243         bt_list_for_each_entry (iter, &node->u.callsite.declaration_list, siblings) {
 244             iter->parent = node;
 245             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 246             if (ret)
 247                 return ret;
 248         }
 249         break;
 250
 251     case NODE_CTF_EXPRESSION:
 252         depth++;
 253         bt_list_for_each_entry (iter, &node->u.ctf_expression.left, siblings) {
 254             iter->parent = node;
 255             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 256             if (ret)
 257                 return ret;
 258         }
 259         bt_list_for_each_entry (iter, &node->u.ctf_expression.right, siblings) {
 260             iter->parent = node;
 261             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 262             if (ret)
 263                 return ret;
 264         }
 265         depth--;
 266         break;
 267     case NODE_UNARY_EXPRESSION:
 268         return ctf_visitor_unary_expression(depth, node, logger);
 269
 270     case NODE_TYPEDEF:
 271         depth++;
 272         node->u.field_class_def.field_class_specifier_list->parent = node;
 273         ret = ctf_visitor_parent_links(depth + 1,
 274                                        node->u.field_class_def.field_class_specifier_list, logger);
 275         if (ret)
 276             return ret;
 277         bt_list_for_each_entry (iter, &node->u.field_class_def.field_class_declarators, siblings) {
 278             iter->parent = node;
 279             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 280             if (ret)
 281                 return ret;
 282         }
 283         depth--;
 284         break;
 285     case NODE_TYPEALIAS_TARGET:
 286         depth++;
 287         node->u.field_class_alias_target.field_class_specifier_list->parent = node;
 288         ret = ctf_visitor_parent_links(
 289             depth + 1, node->u.field_class_alias_target.field_class_specifier_list, logger);
 290         if (ret)
 291             return ret;
 292         bt_list_for_each_entry (iter, &node->u.field_class_alias_target.field_class_declarators,
 293                                 siblings) {
 294             iter->parent = node;
 295             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 296             if (ret)
 297                 return ret;
 298         }
 299         depth--;
 300         break;
 301     case NODE_TYPEALIAS_ALIAS:
 302         depth++;
 303         node->u.field_class_alias_name.field_class_specifier_list->parent = node;
 304         ret = ctf_visitor_parent_links(
 305             depth + 1, node->u.field_class_alias_name.field_class_specifier_list, logger);
 306         if (ret)
 307             return ret;
 308         bt_list_for_each_entry (iter, &node->u.field_class_alias_name.field_class_declarators,
 309                                 siblings) {
 310             iter->parent = node;
 311             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 312             if (ret)
 313                 return ret;
 314         }
 315         depth--;
 316         break;
 317     case NODE_TYPEALIAS:
 318         node->u.field_class_alias.target->parent = node;
 319         ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.target, logger);
 320         if (ret)
 321             return ret;
 322         node->u.field_class_alias.alias->parent = node;
 323         ret = ctf_visitor_parent_links(depth + 1, node->u.field_class_alias.alias, logger);
 324         if (ret)
 325             return ret;
 326         break;
 327
 328     case NODE_TYPE_SPECIFIER_LIST:
 329         bt_list_for_each_entry (iter, &node->u.field_class_specifier_list.head, siblings) {
 330             iter->parent = node;
 331             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 332             if (ret)
 333                 return ret;
 334         }
 335         break;
 336
 337     case NODE_TYPE_SPECIFIER:
 338         ret = ctf_visitor_type_specifier(depth, node, logger);
 339         if (ret)
 340             return ret;
 341         break;
 342     case NODE_POINTER:
 343         break;
 344     case NODE_TYPE_DECLARATOR:
 345         ret = ctf_visitor_field_class_declarator(depth, node, logger);
 346         if (ret)
 347             return ret;
 348         break;
 349
 350     case NODE_FLOATING_POINT:
 351         bt_list_for_each_entry (iter, &node->u.floating_point.expressions, siblings) {
 352             iter->parent = node;
 353             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 354             if (ret)
 355                 return ret;
 356         }
 357         break;
 358     case NODE_INTEGER:
 359         bt_list_for_each_entry (iter, &node->u.integer.expressions, siblings) {
 360             iter->parent = node;
 361             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 362             if (ret)
 363                 return ret;
 364         }
 365         break;
 366     case NODE_STRING:
 367         bt_list_for_each_entry (iter, &node->u.string.expressions, siblings) {
 368             iter->parent = node;
 369             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 370             if (ret)
 371                 return ret;
 372         }
 373         break;
 374     case NODE_ENUMERATOR:
 375         bt_list_for_each_entry (iter, &node->u.enumerator.values, siblings) {
 376             iter->parent = node;
 377             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 378             if (ret)
 379                 return ret;
 380         }
 381         break;
 382     case NODE_ENUM:
 383         depth++;
 384         if (node->u._enum.container_field_class) {
 385             ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_field_class, logger);
 386             if (ret)
 387                 return ret;
 388         }
 389
 390         bt_list_for_each_entry (iter, &node->u._enum.enumerator_list, siblings) {
 391             iter->parent = node;
 392             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 393             if (ret)
 394                 return ret;
 395         }
 396         depth--;
 397         break;
 398     case NODE_STRUCT_OR_VARIANT_DECLARATION:
 399         node->u.struct_or_variant_declaration.field_class_specifier_list->parent = node;
 400         ret = ctf_visitor_parent_links(
 401             depth + 1, node->u.struct_or_variant_declaration.field_class_specifier_list, logger);
 402         if (ret)
 403             return ret;
 404         bt_list_for_each_entry (
 405             iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) {
 406             iter->parent = node;
 407             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 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(depth + 1, iter, logger);
 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(depth + 1, iter, logger);
 424             if (ret)
 425                 return ret;
 426         }
 427         bt_list_for_each_entry (iter, &node->u._struct.min_align, siblings) {
 428             iter->parent = node;
 429             ret = ctf_visitor_parent_links(depth + 1, iter, logger);
 430             if (ret)
 431                 return ret;
 432         }
 433         break;
 434
 435     case NODE_UNKNOWN:
 436     default:
 437         _BT_CPPLOGE_APPEND_CAUSE_LINENO(logger, node->lineno, "Unknown node type: type={}\n",
 438                                         (int) node->type);
 439         return -EINVAL;
 440     }
 441     return ret;
 442 }