formats/ctf/metadata/ctf-visitor-generate-io-struct.c

   1 /*
   2  * ctf-visitor-generate-io-struct.c
   3  *
   4  * Common Trace Format Metadata Visitor (generate I/O structures).
   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 #define _cds_list_first_entry(ptr, type, member)        \
  35         cds_list_entry((ptr)->next, type, member)
  36
  37 static
  38 int ctf_visitor_print_type_specifier(FILE *fd, int depth, struct ctf_node *node)
  39 {
  40         print_tabs(fd, depth);
  41         fprintf(fd, "<type_specifier \"");
  42
  43         switch (node->u.type_specifier.type) {
  44         case TYPESPEC_VOID:
  45                 fprintf(fd, "void");
  46                 break;
  47         case TYPESPEC_CHAR:
  48                 fprintf(fd, "char");
  49                 break;
  50         case TYPESPEC_SHORT:
  51                 fprintf(fd, "short");
  52                 break;
  53         case TYPESPEC_INT:
  54                 fprintf(fd, "int");
  55                 break;
  56         case TYPESPEC_LONG:
  57                 fprintf(fd, "long");
  58                 break;
  59         case TYPESPEC_FLOAT:
  60                 fprintf(fd, "float");
  61                 break;
  62         case TYPESPEC_DOUBLE:
  63                 fprintf(fd, "double");
  64                 break;
  65         case TYPESPEC_SIGNED:
  66                 fprintf(fd, "signed");
  67                 break;
  68         case TYPESPEC_UNSIGNED:
  69                 fprintf(fd, "unsigned");
  70                 break;
  71         case TYPESPEC_BOOL:
  72                 fprintf(fd, "bool");
  73                 break;
  74         case TYPESPEC_COMPLEX:
  75                 fprintf(fd, "complex");
  76                 break;
  77         case TYPESPEC_CONST:
  78                 fprintf(fd, "const");
  79                 break;
  80         case TYPESPEC_ID_TYPE:
  81                 fprintf(fd, "%s", node->u.type_specifier.id_type);
  82                 break;
  83
  84         case TYPESPEC_UNKNOWN:
  85         default:
  86                 fprintf(stderr, "[error] %s: unknown type specifier %d\n", __func__,
  87                         (int) node->u.type_specifier.type);
  88                 return -EINVAL;
  89         }
  90         fprintf(fd, "\"/>\n");
  91         return 0;
  92 }
  93
  94 static
  95 int ctf_visitor_print_type_declarator(FILE *fd, int depth, struct ctf_node *node)
  96 {
  97         int ret = 0;
  98         struct ctf_node *iter;
  99
 100         print_tabs(fd, depth);
 101         fprintf(fd, "<type_declarator>\n");
 102         depth++;
 103
 104         if (!cds_list_empty(&node->u.type_declarator.pointers)) {
 105                 print_tabs(fd, depth);
 106                 fprintf(fd, "<pointers>\n");
 107                 cds_list_for_each_entry(iter, &node->u.type_declarator.pointers,
 108                                         siblings) {
 109                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 110                         if (ret)
 111                                 return ret;
 112                 }
 113                 print_tabs(fd, depth);
 114                 fprintf(fd, "</pointers>\n");
 115         }
 116
 117         switch (node->u.type_declarator.type) {
 118         case TYPEDEC_ID:
 119                 if (node->u.type_declarator.u.id) {
 120                         print_tabs(fd, depth);
 121                         fprintf(fd, "<id \"");
 122                         fprintf(fd, "%s", node->u.type_declarator.u.id);
 123                         fprintf(fd, "\" />\n");
 124                 }
 125                 break;
 126         case TYPEDEC_NESTED:
 127                 if (node->u.type_declarator.u.nested.type_declarator) {
 128                         print_tabs(fd, depth);
 129                         fprintf(fd, "<type_declarator>\n");
 130                         ret = ctf_visitor_print_xml(fd, depth + 1,
 131                                 node->u.type_declarator.u.nested.type_declarator);
 132                         if (ret)
 133                                 return ret;
 134                         print_tabs(fd, depth);
 135                         fprintf(fd, "</type_declarator>\n");
 136                 }
 137                 if (node->u.type_declarator.u.nested.length) {
 138                         print_tabs(fd, depth);
 139                         fprintf(fd, "<length>\n");
 140                         ret = ctf_visitor_print_xml(fd, depth + 1,
 141                                 node->u.type_declarator.u.nested.length);
 142                         if (ret)
 143                                 return ret;
 144                         print_tabs(fd, depth);
 145                         fprintf(fd, "</length>\n");
 146                 }
 147                 if (node->u.type_declarator.u.nested.abstract_array) {
 148                         print_tabs(fd, depth);
 149                         fprintf(fd, "<length>\n");
 150                         print_tabs(fd, depth);
 151                         fprintf(fd, "</length>\n");
 152                 }
 153                 if (node->u.type_declarator.bitfield_len) {
 154                         print_tabs(fd, depth);
 155                         fprintf(fd, "<bitfield_len>\n");
 156                         ret = ctf_visitor_print_xml(fd, depth + 1,
 157                                 node->u.type_declarator.bitfield_len);
 158                         if (ret)
 159                                 return ret;
 160                         print_tabs(fd, depth);
 161                         fprintf(fd, "</bitfield_len>\n");
 162                 }
 163                 break;
 164         case TYPEDEC_UNKNOWN:
 165         default:
 166                 fprintf(stderr, "[error] %s: unknown type declarator %d\n", __func__,
 167                         (int) node->u.type_declarator.type);
 168                 return -EINVAL;
 169         }
 170
 171         depth--;
 172         print_tabs(fd, depth);
 173         fprintf(fd, "</type_declarator>\n");
 174         return 0;
 175 }
 176
 177 /*
 178  * String returned must be freed by the caller.
 179  */
 180 static
 181 char *concatenate_unary_strings(struct list_head *head)
 182 {
 183
 184 }
 185
 186 static
 187 int get_unary_unsigned(struct list_head *head, uint64_t *value)
 188 {
 189
 190 }
 191
 192 static
 193 int get_unary_uuid(struct list_head *head, uuid_t *uuid)
 194 {
 195
 196 }
 197
 198 static
 199 struct ctf_stream *trace_stream_lookup(struct ctf_trace *trace, uint64_t stream_id)
 200 {
 201         if (trace->streams->len <= stream_id)
 202                 return NULL;
 203         return g_ptr_array_index(trace->streams, stream_id);
 204 }
 205
 206 /*
 207  * Also add named variant, struct or enum to the current declaration scope.
 208  */
 209 static
 210 struct ctf_declaration *ctf_declaration_specifier_visit(FILE *fd,
 211                 int depth, struct list_head *head,
 212                 struct declaration_scope *declaration_scope)
 213 {
 214         struct ctf_declaration *declaration;
 215         struct node *first;
 216
 217         first = _cds_list_first_entry(head, struct node, siblings);
 218
 219         switch (first->type) {
 220         case NODE_STRUCT:
 221                 /*
 222                  * For named struct (without body), lookup in
 223                  * declaration scope and create declaration copy.
 224                  */
 225                 /* For named struct (with body), create type and add to declaration scope */
 226                 /* For unnamed struct, create type */
 227                 break;
 228         case NODE_VARIANT:
 229                 /*
 230                  * For named variant (without body), lookup in
 231                  * declaration scope and create declaration copy.
 232                  */
 233                 /* For named variant (with body), create type and add to declaration scope */
 234                 /* For unnamed variant, create type */
 235                 /* If variant has a tag field specifier, assign tag name. */
 236                 break;
 237         case NODE_ENUM:
 238                 /*
 239                  * For named enum (without body), lookup in declaration
 240                  * scope and create declaration copy.
 241                  */
 242                 /* For named enum (with body), create type and add to declaration scope */
 243                 /* For unnamed enum, create type */
 244                 /* Enumerations need to have their size/type specifier (< >). */
 245                 break;
 246         case NODE_INTEGER:
 247                 /*
 248                  * Create an integer declaration.
 249                  */
 250                 break;
 251         case NODE_FLOATING_POINT:
 252                 /*
 253                  * Create a floating point declaration.
 254                  */
 255                 break;
 256         case NODE_STRING:
 257                 /*
 258                  * Create a string declaration.
 259                  */
 260                 break;
 261         case NODE_TYPE_SPECIFIER:
 262                 /*
 263                  * Lookup named type in typedef declarations (in
 264                  * declaration scope). Create a copy of the declaration.
 265                  */
 266                 break;
 267
 268         }
 269 }
 270
 271 static
 272 int ctf_typedef_declarator_visit(FILE *fd, int depth,
 273                 struct list_head *declaration_specifier,
 274                 struct node *type_declarator,
 275                 struct declaration_scope *declaration_scope)
 276 {
 277         /*
 278          * Build the type using declaration specifier (creating
 279          * declaration from type_specifier), then apply type declarator,
 280          * add the resulting type to the current declaration scope.
 281          */
 282         cds_list_for_each_entry(iter, declaration_specifier, siblings) {
 283
 284
 285         }
 286         return 0;
 287 }
 288
 289 static
 290 int ctf_typedef_visit(FILE *fd, int depth,
 291                 struct list_head *declaration_specifier,
 292                 struct list_head *type_declarators,
 293                 struct declaration_scope *declaration_scope)
 294 {
 295         struct ctf_node *iter;
 296
 297         cds_list_for_each_entry(iter, type_declarators, siblings) {
 298                 ret = ctf_typedef_declarator_visit(fd, depth + 1,
 299                         &node->u._typedef.declaration_specifier, iter,
 300                         declaration_scope);
 301                 if (ret)
 302                         return ret;
 303         }
 304         return 0;
 305 }
 306
 307 static
 308 int ctf_typealias_visit(FILE *fd, int depth, struct ctf_node *target,
 309                 struct ctf_node *alias,
 310                 struct declaration_scope *declaration_scope)
 311 {
 312         /*
 313          * Build target type, check that it is reachable in current
 314          * declaration scope.
 315          */
 316
 317         /* Only one type declarator is allowed */
 318
 319         /* Build alias type, add to current declaration scope. */
 320         /* Only one type declarator is allowed */
 321 }
 322
 323 static
 324 int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_event *event, struct ctf_trace *trace)
 325 {
 326         int ret = 0;
 327
 328         switch (node->type) {
 329         case NODE_TYPEDEF:
 330                 ret = ctf_typedef_visit(fd, depth + 1,
 331                                         &node->u._typedef.declaration_specifier,
 332                                         &node->u._typedef.type_declarators,
 333                                         event->declaration_scope);
 334                 if (ret)
 335                         return ret;
 336                 break;
 337         case NODE_TYPEALIAS:
 338                 ret = ctf_typealias_visit(fd, depth + 1,
 339                                 &node->u.typealias.target, &node->u.typealias.alias
 340                                 event->declaration_scope);
 341                 if (ret)
 342                         return ret;
 343                 break;
 344         case NODE_CTF_EXPRESSION:
 345         {
 346                 char *left;
 347
 348                 left = concatenate_unary_strings(&node->u.ctf_expression.left);
 349                 if (!strcmp(left, "name")) {
 350                         char *right;
 351
 352                         if (CTF_EVENT_FIELD_IS_SET(event, name))
 353                                 return -EPERM;
 354                         right = concatenate_unary_strings(&node->u.ctf_expression.right);
 355                         if (!right) {
 356                                 fprintf(stderr, "[error] %s: unexpected unary expression for event name\n", __func__);
 357                                 return -EINVAL;
 358                         }
 359                         event->name = g_quark_from_string(right);
 360                         free(right);
 361                         CTF_EVENT_SET_FIELD(event, name);
 362                 } else if (!strcmp(left, "id")) {
 363                         if (CTF_EVENT_FIELD_IS_SET(event, id))
 364                                 return -EPERM;
 365                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->id);
 366                         if (ret) {
 367                                 fprintf(stderr, "[error] %s: unexpected unary expression for event id\n", __func__);
 368                                 return -EINVAL;
 369                         }
 370                         CTF_EVENT_SET_FIELD(event, id);
 371                 } else if (!strcmp(left, "stream_id")) {
 372                         if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
 373                                 return -EPERM;
 374                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
 375                         if (ret) {
 376                                 fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
 377                                 return -EINVAL;
 378                         }
 379                         event->stream = trace_stream_lookup(trace, event->stream_id);
 380                         if (!event->stream) {
 381                                 fprintf(stderr, "[error] %s: stream id %" PRIu64 " cannot be found\n", __func__, event->stream_id);
 382                                 return -EINVAL;
 383                         }
 384                         event->definition_scope = new_definition_scope(stream->definition_scope);
 385                         if (!event->definition_scope) {
 386                                 fprintf(stderr, "[error] %s: Error allocating declaration scope\n", __func__);
 387                                 return -EPERM;
 388                         }
 389                         CTF_EVENT_SET_FIELD(event, stream_id);
 390                 } else if (!strcmp(left, "context")) {
 391                         struct declaration *declaration;
 392
 393                         if (!event->definition_scope)
 394                                 return -EPERM;
 395                         declaration = ctf_declaration_specifier_visit(fd, depth,
 396                                         &node->u.ctf_expression.right,
 397                                         event->declaration_scope);
 398                         if (!declaration)
 399                                 return -EPERM;
 400                         if (declaration->type->id != CTF_TYPE_STRUCT)
 401                                 return -EPERM;
 402                         /* TODO: definition */
 403                         event->context = container_of(declaration, struct declaration_struct, p);
 404                 } else if (!strcmp(left, "fields")) {
 405                         struct declaration *declaration;
 406
 407                         if (!event->definition_scope)
 408                                 return -EPERM;
 409                         declaration = ctf_declaration_specifier_visit(fd, depth,
 410                                         &node->u.ctf_expression.right,
 411                                         event->declaration_scope);
 412                         if (!declaration)
 413                                 return -EPERM;
 414                         if (declaration->type->id != CTF_TYPE_STRUCT)
 415                                 return -EPERM;
 416                         /* TODO: definition */
 417                         event->fields = container_of(declaration, struct declaration_struct, p);
 418                 }
 419                 free(left);
 420                 break;
 421         }
 422         default:
 423                 return -EPERM;
 424         /* TODO: declaration specifier should be added. */
 425         }
 426
 427         return 0;
 428 }
 429
 430 static
 431 int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
 432                     struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
 433 {
 434         int ret = 0;
 435         struct ctf_node *iter;
 436         struct ctf_event *event;
 437
 438         event = g_new0(struct ctf_event, 1);
 439         event->declaration_scope = new_declaration_scope(parent_declaration_scope);
 440         cds_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
 441                 ret = ctf_event_declaration_visit(fd, depth + 1, iter, event, trace);
 442                 if (ret)
 443                         goto error;
 444         }
 445         if (!CTF_EVENT_FIELD_IS_SET(event, name)) {
 446                 ret = -EPERM;
 447                 goto error;
 448         }
 449         if (!CTF_EVENT_FIELD_IS_SET(event, id)) {
 450                 ret = -EPERM;
 451                 goto error;
 452         }
 453         if (!CTF_EVENT_FIELD_IS_SET(event, stream_id)) {
 454                 ret = -EPERM;
 455                 goto error;
 456         }
 457         if (event->stream->events_by_id->len <= event->id)
 458                 g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
 459         g_ptr_array_index(event->stream->events_by_id, event->id) = event;
 460         g_hash_table_insert(event->stream->event_quark_to_id,
 461                             (gpointer)(unsigned long) event->name,
 462                             &event->id);
 463         return 0;
 464
 465 error:
 466         declaration_unref(event->fields);
 467         declaration_unref(event->context);
 468         free_definition_scope(event->definition_scope);
 469         free_declaration_scope(event->declaration_scope);
 470         g_free(event);
 471         return ret;
 472 }
 473
 474
 475 static
 476 int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_stream *stream, struct ctf_trace *trace)
 477 {
 478         int ret = 0;
 479
 480         switch (node->type) {
 481         case NODE_TYPEDEF:
 482                 ret = ctf_typedef_visit(fd, depth + 1,
 483                                         &node->u._typedef.declaration_specifier,
 484                                         &node->u._typedef.type_declarators,
 485                                         stream->declaration_scope);
 486                 if (ret)
 487                         return ret;
 488                 break;
 489         case NODE_TYPEALIAS:
 490                 ret = ctf_typealias_visit(fd, depth + 1,
 491                                 &node->u.typealias.target, &node->u.typealias.alias
 492                                 stream->declaration_scope);
 493                 if (ret)
 494                         return ret;
 495                 break;
 496         case NODE_CTF_EXPRESSION:
 497         {
 498                 char *left;
 499
 500                 left = concatenate_unary_strings(&node->u.ctf_expression.left);
 501                 if (!strcmp(left, "stream_id")) {
 502                         if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
 503                                 return -EPERM;
 504                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
 505                         if (ret) {
 506                                 fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
 507                                 return -EINVAL;
 508                         }
 509                         CTF_EVENT_SET_FIELD(event, stream_id);
 510                 } else if (!strcmp(left, "event_header")) {
 511                         struct declaration *declaration;
 512
 513                         declaration = ctf_declaration_specifier_visit(fd, depth,
 514                                         &node->u.ctf_expression.right,
 515                                         stream->declaration_scope, stream->definition_scope);
 516                         if (!declaration)
 517                                 return -EPERM;
 518                         if (declaration->type->id != CTF_TYPE_STRUCT)
 519                                 return -EPERM;
 520                         /* TODO: definition */
 521                         stream->event_header = container_of(declaration, struct declaration_struct, p);
 522                 } else if (!strcmp(left, "event_context")) {
 523                         struct declaration *declaration;
 524
 525                         declaration = ctf_declaration_specifier_visit(fd, depth,
 526                                         &node->u.ctf_expression.right,
 527                                         stream->declaration_scope);
 528                         if (!declaration)
 529                                 return -EPERM;
 530                         if (declaration->type->id != CTF_TYPE_STRUCT)
 531                                 return -EPERM;
 532                         /* TODO: definition */
 533                         stream->event_context = container_of(declaration, struct declaration_struct, p);
 534                 } else if (!strcmp(left, "packet_context")) {
 535                         struct declaration *declaration;
 536
 537                         declaration = ctf_declaration_specifier_visit(fd, depth,
 538                                         &node->u.ctf_expression.right,
 539                                         stream->declaration_scope);
 540                         if (!declaration)
 541                                 return -EPERM;
 542                         if (declaration->type->id != CTF_TYPE_STRUCT)
 543                                 return -EPERM;
 544                         /* TODO: definition */
 545                         stream->packet_context = container_of(declaration, struct declaration_struct, p);
 546                 }
 547                 free(left);
 548                 break;
 549         }
 550         default:
 551                 return -EPERM;
 552         /* TODO: declaration specifier should be added. */
 553         }
 554
 555         return 0;
 556 }
 557
 558 static
 559 int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
 560                      struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
 561 {
 562         int ret = 0;
 563         struct ctf_node *iter;
 564         struct ctf_stream *stream;
 565
 566         stream = g_new0(struct ctf_stream, 1);
 567         stream->declaration_scope = new_declaration_scope(parent_declaration_scope);
 568         stream->definition_scope = new_definition_scope(trace->definition_scope);
 569         stream->events_by_id = g_ptr_array_new();
 570         stream->event_quark_to_id = g_hash_table_new(g_int_hash, g_int_equal);
 571         cds_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
 572                 ret = ctf_stream_declaration_visit(fd, depth + 1, iter, stream, trace);
 573                 if (ret)
 574                         goto error;
 575         }
 576         if (!CTF_EVENT_FIELD_IS_SET(stream, stream_id)) {
 577                 ret = -EPERM;
 578                 goto error;
 579         }
 580         if (trace->streams->len <= stream->stream_id)
 581                 g_ptr_array_set_size(trace->streams, stream->stream_id + 1);
 582         g_ptr_array_index(trace->streams, stream->stream_id) = stream;
 583         return 0;
 584
 585 error:
 586         declaration_unref(stream->event_header);
 587         declaration_unref(stream->event_context);
 588         declaration_unref(stream->packet_context);
 589         g_ptr_array_free(stream->events_by_id, TRUE);
 590         g_hash_table_free(stream->event_quark_to_id);
 591         free_definition_scope(stream->definition_scope);
 592         free_declaration_scope(stream->declaration_scope);
 593         g_free(stream);
 594         return ret;
 595 }
 596
 597 static
 598 int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
 599 {
 600         int ret = 0;
 601
 602         switch (node->type) {
 603         case NODE_TYPEDEF:
 604                 ret = ctf_typedef_visit(fd, depth + 1,
 605                                         &node->u._typedef.declaration_specifier,
 606                                         &node->u._typedef.type_declarators,
 607                                         trace->declaration_scope);
 608                 if (ret)
 609                         return ret;
 610                 break;
 611         case NODE_TYPEALIAS:
 612                 ret = ctf_typealias_visit(fd, depth + 1,
 613                                 &node->u.typealias.target, &node->u.typealias.alias
 614                                 trace->declaration_scope);
 615                 if (ret)
 616                         return ret;
 617                 break;
 618         case NODE_CTF_EXPRESSION:
 619         {
 620                 char *left;
 621
 622                 left = concatenate_unary_strings(&node->u.ctf_expression.left);
 623                 if (!strcmp(left, "major")) {
 624                         if (CTF_EVENT_FIELD_IS_SET(trace, major))
 625                                 return -EPERM;
 626                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->major);
 627                         if (ret) {
 628                                 fprintf(stderr, "[error] %s: unexpected unary expression for trace major number\n", __func__);
 629                                 return -EINVAL;
 630                         }
 631                         CTF_EVENT_SET_FIELD(trace, major);
 632                 } else if (!strcmp(left, "minor")) {
 633                         if (CTF_EVENT_FIELD_IS_SET(trace, minor))
 634                                 return -EPERM;
 635                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->minor);
 636                         if (ret) {
 637                                 fprintf(stderr, "[error] %s: unexpected unary expression for trace minor number\n", __func__);
 638                                 return -EINVAL;
 639                         }
 640                         CTF_EVENT_SET_FIELD(trace, minor);
 641                 } else if (!strcmp(left, "word_size")) {
 642                         if (CTF_EVENT_FIELD_IS_SET(trace, word_size))
 643                                 return -EPERM;
 644                         ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->word_size);
 645                         if (ret) {
 646                                 fprintf(stderr, "[error] %s: unexpected unary expression for trace word_size\n", __func__);
 647                                 return -EINVAL;
 648                         }
 649                         CTF_EVENT_SET_FIELD(trace, word_size);
 650                 } else if (!strcmp(left, "uuid")) {
 651                         if (CTF_EVENT_FIELD_IS_SET(trace, uuid))
 652                                 return -EPERM;
 653                         ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
 654                         if (ret) {
 655                                 fprintf(stderr, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
 656                                 return -EINVAL;
 657                         }
 658                         CTF_EVENT_SET_FIELD(trace, uuid);
 659                 }
 660                 free(left);
 661                 break;
 662         }
 663         default:
 664                 return -EPERM;
 665         /* TODO: declaration specifier should be added. */
 666         }
 667
 668         return 0;
 669 }
 670
 671
 672 static
 673 int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
 674 {
 675         int ret = 0;
 676         struct ctf_node *iter;
 677
 678         if (trace->declaration_scope)
 679                 return -EEXIST;
 680         trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
 681         trace->definition_scope = new_definition_scope(trace->root_definition_scope);
 682         trace->streams = g_ptr_array_new();
 683         cds_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
 684                 ret = ctf_trace_declaration_visit(fd, depth + 1, iter, trace);
 685                 if (ret)
 686                         goto error;
 687         }
 688         if (!CTF_EVENT_FIELD_IS_SET(trace, major)) {
 689                 ret = -EPERM;
 690                 goto error;
 691         }
 692         if (!CTF_EVENT_FIELD_IS_SET(trace, minor)) {
 693                 ret = -EPERM;
 694                 goto error;
 695         }
 696         if (!CTF_EVENT_FIELD_IS_SET(trace, uuid)) {
 697                 ret = -EPERM;
 698                 goto error;
 699         }
 700         if (!CTF_EVENT_FIELD_IS_SET(trace, word_size)) {
 701                 ret = -EPERM;
 702                 goto error;
 703         }
 704         return 0;
 705
 706 error:
 707         g_ptr_array_free(trace->streams, TRUE);
 708         free_definition_scope(stream->definition_scope);
 709         free_declaration_scope(stream->declaration_scope);
 710         return ret;
 711 }
 712
 713 int _ctf_visitor(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
 714 {
 715         int ret = 0;
 716         struct ctf_node *iter;
 717
 718         switch (node->type) {
 719         case NODE_ROOT:
 720                 cds_list_for_each_entry(iter, &node->u.root._typedef,
 721                                         siblings) {
 722                         ret = ctf_typedef_visit(fd, depth + 1,
 723                                                 &iter->u._typedef.declaration_specifier,
 724                                                 &iter->u._typedef.type_declarators,
 725                                                 trace->declaration_scope);
 726                         if (ret)
 727                                 return ret;
 728                 }
 729                 cds_list_for_each_entry(iter, &node->u.root.typealias,
 730                                         siblings) {
 731                         ret = ctf_typealias_visit(fd, depth + 1,
 732                                         &iter->u.typealias.target, &iter->u.typealias.alias
 733                                         trace->declaration_scope);
 734                         if (ret)
 735                                 return ret;
 736                 }
 737                 cds_list_for_each_entry(iter, &node->u.root.declaration_specifier, siblings) {
 738                         ret = ctf_declaration_specifier_visit(fd, depth, iter,
 739                                         trace->root_declaration_scope);
 740                         if (ret)
 741                                 return ret;
 742                 }
 743                 cds_list_for_each_entry(iter, &node->u.root.trace, siblings) {
 744                         ret = ctf_trace_visit(fd, depth + 1, iter, trace);
 745                         if (ret)
 746                                 return ret;
 747                 }
 748                 cds_list_for_each_entry(iter, &node->u.root.stream, siblings) {
 749                         ret = ctf_stream_visit(fd, depth + 1, iter,
 750                                                trace->declaration_scope, trace);
 751                         if (ret)
 752                                 return ret;
 753                 }
 754                 cds_list_for_each_entry(iter, &node->u.root.event, siblings) {
 755                         ret = ctf_event_visit(fd, depth + 1, iter,
 756                                               trace->declaration_scope, trace);
 757                         if (ret)
 758                                 return ret;
 759                 }
 760                 break;
 761
 762         case NODE_TYPEALIAS_TARGET:
 763                 print_tabs(fd, depth);
 764                 fprintf(fd, "<target>\n");
 765                 depth++;
 766
 767                 print_tabs(fd, depth);
 768                 fprintf(fd, "<declaration_specifier>\n");
 769                 cds_list_for_each_entry(iter, &node->u.typealias_target.declaration_specifier, siblings) {
 770                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 771                         if (ret)
 772                                 return ret;
 773                 }
 774                 print_tabs(fd, depth);
 775                 fprintf(fd, "</declaration_specifier>\n");
 776
 777                 print_tabs(fd, depth);
 778                 fprintf(fd, "<type_declarators>\n");
 779                 cds_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
 780                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 781                         if (ret)
 782                                 return ret;
 783                 }
 784                 print_tabs(fd, depth);
 785                 fprintf(fd, "</type_declarators>\n");
 786
 787                 depth--;
 788                 print_tabs(fd, depth);
 789                 fprintf(fd, "</target>\n");
 790                 break;
 791         case NODE_TYPEALIAS_ALIAS:
 792                 print_tabs(fd, depth);
 793                 fprintf(fd, "<alias>\n");
 794                 depth++;
 795
 796                 print_tabs(fd, depth);
 797                 fprintf(fd, "<declaration_specifier>\n");
 798                 cds_list_for_each_entry(iter, &node->u.typealias_alias.declaration_specifier, siblings) {
 799                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 800                         if (ret)
 801                                 return ret;
 802                 }
 803                 print_tabs(fd, depth);
 804                 fprintf(fd, "</declaration_specifier>\n");
 805
 806                 print_tabs(fd, depth);
 807                 fprintf(fd, "<type_declarators>\n");
 808                 cds_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
 809                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 810                         if (ret)
 811                                 return ret;
 812                 }
 813                 print_tabs(fd, depth);
 814                 fprintf(fd, "</type_declarators>\n");
 815
 816                 depth--;
 817                 print_tabs(fd, depth);
 818                 fprintf(fd, "</alias>\n");
 819                 break;
 820         case NODE_TYPEALIAS:
 821                 print_tabs(fd, depth);
 822                 fprintf(fd, "<typealias>\n");
 823                 ret = ctf_visitor_print_xml(fd, depth + 1, node->u.typealias.target);
 824                 if (ret)
 825                         return ret;
 826                 ret = ctf_visitor_print_xml(fd, depth + 1, node->u.typealias.alias);
 827                 if (ret)
 828                         return ret;
 829                 print_tabs(fd, depth);
 830                 fprintf(fd, "</typealias>\n");
 831                 break;
 832
 833         case NODE_TYPE_SPECIFIER:
 834                 ret = ctf_visitor_print_type_specifier(fd, depth, node);
 835                 if (ret)
 836                         return ret;
 837                 break;
 838         case NODE_POINTER:
 839                 print_tabs(fd, depth);
 840                 if (node->u.pointer.const_qualifier)
 841                         fprintf(fd, "<const_pointer />\n");
 842                 else
 843                         fprintf(fd, "<pointer />\n");
 844                 break;
 845         case NODE_TYPE_DECLARATOR:
 846                 ret = ctf_visitor_print_type_declarator(fd, depth, node);
 847                 if (ret)
 848                         return ret;
 849                 break;
 850
 851         case NODE_FLOATING_POINT:
 852                 print_tabs(fd, depth);
 853                 fprintf(fd, "<floating_point>\n");
 854                 cds_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
 855                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 856                         if (ret)
 857                                 return ret;
 858                 }
 859                 print_tabs(fd, depth);
 860                 fprintf(fd, "</floating_point>\n");
 861                 break;
 862         case NODE_INTEGER:
 863                 print_tabs(fd, depth);
 864                 fprintf(fd, "<integer>\n");
 865                 cds_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
 866                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 867                         if (ret)
 868                                 return ret;
 869                 }
 870                 print_tabs(fd, depth);
 871                 fprintf(fd, "</integer>\n");
 872                 break;
 873         case NODE_STRING:
 874                 print_tabs(fd, depth);
 875                 fprintf(fd, "<string>\n");
 876                 cds_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
 877                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 878                         if (ret)
 879                                 return ret;
 880                 }
 881                 print_tabs(fd, depth);
 882                 fprintf(fd, "</string>\n");
 883                 break;
 884         case NODE_ENUMERATOR:
 885                 print_tabs(fd, depth);
 886                 fprintf(fd, "<enumerator");
 887                 if (node->u.enumerator.id)
 888                         fprintf(fd, " id=\"%s\"", node->u.enumerator.id);
 889                 fprintf(fd, ">\n");
 890                 cds_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
 891                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 892                         if (ret)
 893                                 return ret;
 894                 }
 895                 print_tabs(fd, depth);
 896                 fprintf(fd, "</enumerator>\n");
 897                 break;
 898         case NODE_ENUM:
 899                 print_tabs(fd, depth);
 900                 if (node->u._struct.name)
 901                         fprintf(fd, "<enum name=\"%s\">\n",
 902                                 node->u._enum.enum_id);
 903                 else
 904                         fprintf(fd, "<enum >\n");
 905                 depth++;
 906
 907                 if (node->u._enum.container_type) {
 908                         print_tabs(fd, depth);
 909                         fprintf(fd, "<container_type>\n");
 910                         ret = ctf_visitor_print_xml(fd, depth + 1, node->u._enum.container_type);
 911                         if (ret)
 912                                 return ret;
 913                         print_tabs(fd, depth);
 914                         fprintf(fd, "</container_type>\n");
 915                 }
 916
 917                 print_tabs(fd, depth);
 918                 fprintf(fd, "<enumerator_list>\n");
 919                 cds_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
 920                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 921                         if (ret)
 922                                 return ret;
 923                 }
 924                 print_tabs(fd, depth);
 925                 fprintf(fd, "</enumerator_list>\n");
 926
 927                 depth--;
 928                 print_tabs(fd, depth);
 929                 fprintf(fd, "</enum>\n");
 930                 break;
 931         case NODE_STRUCT_OR_VARIANT_DECLARATION:
 932                 print_tabs(fd, depth);
 933                 fprintf(fd, "<declaration_specifier>\n");
 934                 cds_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.declaration_specifier, siblings) {
 935                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 936                         if (ret)
 937                                 return ret;
 938                 }
 939                 print_tabs(fd, depth);
 940                 fprintf(fd, "</declaration_specifier>\n");
 941
 942                 print_tabs(fd, depth);
 943                 fprintf(fd, "<type_declarators>\n");
 944                 cds_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
 945                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 946                         if (ret)
 947                                 return ret;
 948                 }
 949                 print_tabs(fd, depth);
 950                 fprintf(fd, "</type_declarators>\n");
 951                 break;
 952         case NODE_VARIANT:
 953                 print_tabs(fd, depth);
 954                 fprintf(fd, "<variant");
 955                 if (node->u.variant.name)
 956                         fprintf(fd, " name=\"%s\"", node->u.variant.name);
 957                 if (node->u.variant.choice)
 958                         fprintf(fd, " choice=\"%s\"", node->u.variant.choice);
 959                 fprintf(fd, ">\n");
 960                 cds_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
 961                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 962                         if (ret)
 963                                 return ret;
 964                 }
 965                 print_tabs(fd, depth);
 966                 fprintf(fd, "</variant>\n");
 967                 break;
 968         case NODE_STRUCT:
 969                 print_tabs(fd, depth);
 970                 if (node->u._struct.name)
 971                         fprintf(fd, "<struct name=\"%s\">\n",
 972                                 node->u._struct.name);
 973                 else
 974                         fprintf(fd, "<struct>\n");
 975                 cds_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
 976                         ret = ctf_visitor_print_xml(fd, depth + 1, iter);
 977                         if (ret)
 978                                 return ret;
 979                 }
 980                 print_tabs(fd, depth);
 981                 fprintf(fd, "</struct>\n");
 982                 break;
 983
 984         case NODE_UNKNOWN:
 985         default:
 986                 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
 987                         (int) node->type);
 988                 return -EINVAL;
 989         }
 990         return ret;
 991 }