formats/ctf/ir/event-types.c

   1 /*
   2  * event-types.c
   3  *
   4  * Babeltrace CTF IR - Event Types
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/ctf-writer/event-types.h>
  30 #include <babeltrace/ctf-ir/event-types-internal.h>
  31 #include <babeltrace/ctf-ir/utils.h>
  32 #include <babeltrace/ref.h>
  33 #include <babeltrace/ctf-ir/clock.h>
  34 #include <babeltrace/ctf-writer/writer-internal.h>
  35 #include <babeltrace/object-internal.h>
  36 #include <babeltrace/ref.h>
  37 #include <babeltrace/compiler.h>
  38 #include <babeltrace/endian.h>
  39 #include <float.h>
  40 #include <inttypes.h>
  41 #include <stdlib.h>
  42
  43 struct range_overlap_query {
  44         union {
  45                 uint64_t _unsigned;
  46                 int64_t _signed;
  47         } range_start;
  48
  49         union {
  50                 uint64_t _unsigned;
  51                 int64_t _signed;
  52         } range_end;
  53         int overlaps;
  54         GQuark mapping_name;
  55 };
  56
  57 static
  58 void bt_ctf_field_type_destroy(struct bt_object *);
  59 static
  60 void bt_ctf_field_type_integer_destroy(struct bt_ctf_field_type *);
  61 static
  62 void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_field_type *);
  63 static
  64 void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_field_type *);
  65 static
  66 void bt_ctf_field_type_structure_destroy(struct bt_ctf_field_type *);
  67 static
  68 void bt_ctf_field_type_variant_destroy(struct bt_ctf_field_type *);
  69 static
  70 void bt_ctf_field_type_array_destroy(struct bt_ctf_field_type *);
  71 static
  72 void bt_ctf_field_type_sequence_destroy(struct bt_ctf_field_type *);
  73 static
  74 void bt_ctf_field_type_string_destroy(struct bt_ctf_field_type *);
  75
  76 static
  77 void (* const type_destroy_funcs[])(struct bt_ctf_field_type *) = {
  78         [CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_destroy,
  79         [CTF_TYPE_ENUM] =
  80                 bt_ctf_field_type_enumeration_destroy,
  81         [CTF_TYPE_FLOAT] =
  82                 bt_ctf_field_type_floating_point_destroy,
  83         [CTF_TYPE_STRUCT] = bt_ctf_field_type_structure_destroy,
  84         [CTF_TYPE_VARIANT] = bt_ctf_field_type_variant_destroy,
  85         [CTF_TYPE_ARRAY] = bt_ctf_field_type_array_destroy,
  86         [CTF_TYPE_SEQUENCE] = bt_ctf_field_type_sequence_destroy,
  87         [CTF_TYPE_STRING] = bt_ctf_field_type_string_destroy,
  88 };
  89
  90 static
  91 void generic_field_type_freeze(struct bt_ctf_field_type *);
  92 static
  93 void bt_ctf_field_type_enumeration_freeze(struct bt_ctf_field_type *);
  94 static
  95 void bt_ctf_field_type_structure_freeze(struct bt_ctf_field_type *);
  96 static
  97 void bt_ctf_field_type_variant_freeze(struct bt_ctf_field_type *);
  98 static
  99 void bt_ctf_field_type_array_freeze(struct bt_ctf_field_type *);
 100 static
 101 void bt_ctf_field_type_sequence_freeze(struct bt_ctf_field_type *);
 102
 103 static
 104 type_freeze_func const type_freeze_funcs[] = {
 105         [CTF_TYPE_INTEGER] = generic_field_type_freeze,
 106         [CTF_TYPE_ENUM] = bt_ctf_field_type_enumeration_freeze,
 107         [CTF_TYPE_FLOAT] = generic_field_type_freeze,
 108         [CTF_TYPE_STRUCT] = bt_ctf_field_type_structure_freeze,
 109         [CTF_TYPE_VARIANT] = bt_ctf_field_type_variant_freeze,
 110         [CTF_TYPE_ARRAY] = bt_ctf_field_type_array_freeze,
 111         [CTF_TYPE_SEQUENCE] = bt_ctf_field_type_sequence_freeze,
 112         [CTF_TYPE_STRING] = generic_field_type_freeze,
 113 };
 114
 115 static
 116 int bt_ctf_field_type_integer_serialize(struct bt_ctf_field_type *,
 117                 struct metadata_context *);
 118 static
 119 int bt_ctf_field_type_enumeration_serialize(struct bt_ctf_field_type *,
 120                 struct metadata_context *);
 121 static
 122 int bt_ctf_field_type_floating_point_serialize(
 123                 struct bt_ctf_field_type *, struct metadata_context *);
 124 static
 125 int bt_ctf_field_type_structure_serialize(struct bt_ctf_field_type *,
 126                 struct metadata_context *);
 127 static
 128 int bt_ctf_field_type_variant_serialize(struct bt_ctf_field_type *,
 129                 struct metadata_context *);
 130 static
 131 int bt_ctf_field_type_array_serialize(struct bt_ctf_field_type *,
 132                 struct metadata_context *);
 133 static
 134 int bt_ctf_field_type_sequence_serialize(struct bt_ctf_field_type *,
 135                 struct metadata_context *);
 136 static
 137 int bt_ctf_field_type_string_serialize(struct bt_ctf_field_type *,
 138                 struct metadata_context *);
 139
 140 static
 141 type_serialize_func const type_serialize_funcs[] = {
 142         [CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_serialize,
 143         [CTF_TYPE_ENUM] =
 144                 bt_ctf_field_type_enumeration_serialize,
 145         [CTF_TYPE_FLOAT] =
 146                 bt_ctf_field_type_floating_point_serialize,
 147         [CTF_TYPE_STRUCT] =
 148                 bt_ctf_field_type_structure_serialize,
 149         [CTF_TYPE_VARIANT] = bt_ctf_field_type_variant_serialize,
 150         [CTF_TYPE_ARRAY] = bt_ctf_field_type_array_serialize,
 151         [CTF_TYPE_SEQUENCE] = bt_ctf_field_type_sequence_serialize,
 152         [CTF_TYPE_STRING] = bt_ctf_field_type_string_serialize,
 153 };
 154
 155 static
 156 void bt_ctf_field_type_integer_set_byte_order(struct bt_ctf_field_type *,
 157                 int byte_order, int set_native);
 158 static
 159 void bt_ctf_field_type_enumeration_set_byte_order(struct bt_ctf_field_type *,
 160                 int byte_order, int set_native);
 161 static
 162 void bt_ctf_field_type_floating_point_set_byte_order(
 163                 struct bt_ctf_field_type *, int byte_order, int set_native);
 164 static
 165 void bt_ctf_field_type_structure_set_byte_order(struct bt_ctf_field_type *,
 166                 int byte_order, int set_native);
 167 static
 168 void bt_ctf_field_type_variant_set_byte_order(struct bt_ctf_field_type *,
 169                 int byte_order, int set_native);
 170 static
 171 void bt_ctf_field_type_array_set_byte_order(struct bt_ctf_field_type *,
 172                 int byte_order, int set_native);
 173 static
 174 void bt_ctf_field_type_sequence_set_byte_order(struct bt_ctf_field_type *,
 175                 int byte_order, int set_native);
 176
 177 /* The set_native flag only set the byte order if it is set to native */
 178 static
 179 void (* const set_byte_order_funcs[])(struct bt_ctf_field_type *,
 180                 int byte_order, int set_native) = {
 181         [CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_set_byte_order,
 182         [CTF_TYPE_ENUM] =
 183                 bt_ctf_field_type_enumeration_set_byte_order,
 184         [CTF_TYPE_FLOAT] =
 185                 bt_ctf_field_type_floating_point_set_byte_order,
 186         [CTF_TYPE_STRUCT] =
 187                 bt_ctf_field_type_structure_set_byte_order,
 188         [CTF_TYPE_VARIANT] = bt_ctf_field_type_variant_set_byte_order,
 189         [CTF_TYPE_ARRAY] = bt_ctf_field_type_array_set_byte_order,
 190         [CTF_TYPE_SEQUENCE] = bt_ctf_field_type_sequence_set_byte_order,
 191         [CTF_TYPE_STRING] = NULL,
 192 };
 193
 194 static
 195 struct bt_ctf_field_type *bt_ctf_field_type_integer_copy(
 196                 struct bt_ctf_field_type *);
 197 static
 198 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_copy(
 199                 struct bt_ctf_field_type *);
 200 static
 201 struct bt_ctf_field_type *bt_ctf_field_type_floating_point_copy(
 202                 struct bt_ctf_field_type *);
 203 static
 204 struct bt_ctf_field_type *bt_ctf_field_type_structure_copy(
 205                 struct bt_ctf_field_type *);
 206 static
 207 struct bt_ctf_field_type *bt_ctf_field_type_variant_copy(
 208                 struct bt_ctf_field_type *);
 209 static
 210 struct bt_ctf_field_type *bt_ctf_field_type_array_copy(
 211                 struct bt_ctf_field_type *);
 212 static
 213 struct bt_ctf_field_type *bt_ctf_field_type_sequence_copy(
 214                 struct bt_ctf_field_type *);
 215 static
 216 struct bt_ctf_field_type *bt_ctf_field_type_string_copy(
 217                 struct bt_ctf_field_type *);
 218
 219 static
 220 struct bt_ctf_field_type *(* const type_copy_funcs[])(
 221                 struct bt_ctf_field_type *) = {
 222         [CTF_TYPE_INTEGER] = bt_ctf_field_type_integer_copy,
 223         [CTF_TYPE_ENUM] = bt_ctf_field_type_enumeration_copy,
 224         [CTF_TYPE_FLOAT] = bt_ctf_field_type_floating_point_copy,
 225         [CTF_TYPE_STRUCT] = bt_ctf_field_type_structure_copy,
 226         [CTF_TYPE_VARIANT] = bt_ctf_field_type_variant_copy,
 227         [CTF_TYPE_ARRAY] = bt_ctf_field_type_array_copy,
 228         [CTF_TYPE_SEQUENCE] = bt_ctf_field_type_sequence_copy,
 229         [CTF_TYPE_STRING] = bt_ctf_field_type_string_copy,
 230 };
 231
 232 static
 233 void destroy_enumeration_mapping(struct enumeration_mapping *mapping)
 234 {
 235         g_free(mapping);
 236 }
 237
 238 static
 239 void destroy_structure_field(struct structure_field *field)
 240 {
 241         bt_put(field->type);
 242         g_free(field);
 243 }
 244
 245 static
 246 void check_ranges_overlap(gpointer element, gpointer query)
 247 {
 248         struct enumeration_mapping *mapping = element;
 249         struct range_overlap_query *overlap_query = query;
 250
 251         if (mapping->range_start._signed <= overlap_query->range_end._signed
 252                 && overlap_query->range_start._signed <=
 253                 mapping->range_end._signed) {
 254                 overlap_query->overlaps = 1;
 255                 overlap_query->mapping_name = mapping->string;
 256         }
 257
 258         overlap_query->overlaps |=
 259                 mapping->string == overlap_query->mapping_name;
 260 }
 261
 262 static
 263 void check_ranges_overlap_unsigned(gpointer element, gpointer query)
 264 {
 265         struct enumeration_mapping *mapping = element;
 266         struct range_overlap_query *overlap_query = query;
 267
 268         if (mapping->range_start._unsigned <= overlap_query->range_end._unsigned
 269                 && overlap_query->range_start._unsigned <=
 270                 mapping->range_end._unsigned) {
 271                 overlap_query->overlaps = 1;
 272                 overlap_query->mapping_name = mapping->string;
 273         }
 274
 275         overlap_query->overlaps |=
 276                 mapping->string == overlap_query->mapping_name;
 277 }
 278
 279 static
 280 gint compare_enumeration_mappings_signed(struct enumeration_mapping **a,
 281                 struct enumeration_mapping **b)
 282 {
 283         return ((*a)->range_start._signed < (*b)->range_start._signed) ? -1 : 1;
 284 }
 285
 286 static
 287 gint compare_enumeration_mappings_unsigned(struct enumeration_mapping **a,
 288                 struct enumeration_mapping **b)
 289 {
 290         return ((*a)->range_start._unsigned < (*b)->range_start._unsigned) ? -1 : 1;
 291 }
 292
 293 static
 294 void bt_ctf_field_type_init(struct bt_ctf_field_type *type, int init_bo)
 295 {
 296         enum ctf_type_id type_id = type->declaration->id;
 297
 298         assert(type && (type_id > CTF_TYPE_UNKNOWN) &&
 299                 (type_id < NR_CTF_TYPES));
 300
 301         bt_object_init(type, bt_ctf_field_type_destroy);
 302         type->freeze = type_freeze_funcs[type_id];
 303         type->serialize = type_serialize_funcs[type_id];
 304
 305         if (init_bo) {
 306                 int ret = bt_ctf_field_type_set_byte_order(type,
 307                         BT_CTF_BYTE_ORDER_NATIVE);
 308                 assert(!ret);
 309         }
 310
 311         type->declaration->alignment = 1;
 312 }
 313
 314 static
 315 int add_structure_field(GPtrArray *fields,
 316                 GHashTable *field_name_to_index,
 317                 struct bt_ctf_field_type *field_type,
 318                 const char *field_name)
 319 {
 320         int ret = 0;
 321         GQuark name_quark = g_quark_from_string(field_name);
 322         struct structure_field *field;
 323
 324         /* Make sure structure does not contain a field of the same name */
 325         if (g_hash_table_lookup_extended(field_name_to_index,
 326                 GUINT_TO_POINTER(name_quark), NULL, NULL)) {
 327                 ret = -1;
 328                 goto end;
 329         }
 330
 331         field = g_new0(struct structure_field, 1);
 332         if (!field) {
 333                 ret = -1;
 334                 goto end;
 335         }
 336
 337         bt_get(field_type);
 338         field->name = name_quark;
 339         field->type = field_type;
 340         g_hash_table_insert(field_name_to_index,
 341                 (gpointer) (unsigned long) name_quark,
 342                 (gpointer) (unsigned long) fields->len);
 343         g_ptr_array_add(fields, field);
 344 end:
 345         return ret;
 346 }
 347
 348 static
 349 void bt_ctf_field_type_destroy(struct bt_object *obj)
 350 {
 351         struct bt_ctf_field_type *type;
 352         enum ctf_type_id type_id;
 353
 354         type = container_of(obj, struct bt_ctf_field_type, base);
 355         type_id = type->declaration->id;
 356         if (type_id <= CTF_TYPE_UNKNOWN ||
 357                 type_id >= NR_CTF_TYPES) {
 358                 return;
 359         }
 360
 361         type_destroy_funcs[type_id](type);
 362 }
 363
 364 BT_HIDDEN
 365 int bt_ctf_field_type_validate(struct bt_ctf_field_type *type)
 366 {
 367         int ret = 0;
 368
 369         if (!type) {
 370                 ret = -1;
 371                 goto end;
 372         }
 373
 374         switch (type->declaration->id) {
 375         case CTF_TYPE_ENUM:
 376         {
 377                 struct bt_ctf_field_type_enumeration *enumeration =
 378                         container_of(type, struct bt_ctf_field_type_enumeration,
 379                         parent);
 380
 381                 /* Ensure enum has entries */
 382                 ret = enumeration->entries->len ? 0 : -1;
 383                 break;
 384         }
 385         case CTF_TYPE_SEQUENCE:
 386         {
 387                 struct bt_ctf_field_type_sequence *sequence =
 388                         container_of(type, struct bt_ctf_field_type_sequence,
 389                         parent);
 390
 391                 /* length field name should be set at this point */
 392                 ret = sequence->length_field_name->len ? 0 : -1;
 393                 break;
 394         }
 395         case CTF_TYPE_VARIANT:
 396         {
 397                 struct bt_ctf_field_type_variant *variant =
 398                         container_of(type, struct bt_ctf_field_type_variant,
 399                                 parent);
 400
 401                 if (variant->tag_name->len == 0 || !variant->tag) {
 402                         ret = -1;
 403                 }
 404                 break;
 405         }
 406         default:
 407                 break;
 408         }
 409 end:
 410         return ret;
 411 }
 412
 413 struct bt_ctf_field_type *bt_ctf_field_type_integer_create(unsigned int size)
 414 {
 415         struct bt_ctf_field_type_integer *integer =
 416                 g_new0(struct bt_ctf_field_type_integer, 1);
 417
 418         if (!integer || size == 0 || size > 64) {
 419                 return NULL;
 420         }
 421
 422         integer->parent.declaration = &integer->declaration.p;
 423         integer->parent.declaration->id = CTF_TYPE_INTEGER;
 424         integer->declaration.len = size;
 425         integer->declaration.base = BT_CTF_INTEGER_BASE_DECIMAL;
 426         integer->declaration.encoding = CTF_STRING_NONE;
 427         bt_ctf_field_type_init(&integer->parent, TRUE);
 428         return &integer->parent;
 429 }
 430
 431 int bt_ctf_field_type_integer_get_size(struct bt_ctf_field_type *type)
 432 {
 433         int ret = 0;
 434         struct bt_ctf_field_type_integer *integer;
 435
 436         if (!type || type->declaration->id != CTF_TYPE_INTEGER) {
 437                 ret = -1;
 438                 goto end;
 439         }
 440
 441         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 442         ret = (int) integer->declaration.len;
 443 end:
 444         return ret;
 445 }
 446
 447 int bt_ctf_field_type_integer_get_signed(struct bt_ctf_field_type *type)
 448 {
 449         int ret = 0;
 450         struct bt_ctf_field_type_integer *integer;
 451
 452         if (!type || type->declaration->id != CTF_TYPE_INTEGER) {
 453                 ret = -1;
 454                 goto end;
 455         }
 456
 457         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 458         ret = integer->declaration.signedness;
 459 end:
 460         return ret;
 461 }
 462
 463 int bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *type,
 464                 int is_signed)
 465 {
 466         int ret = 0;
 467         struct bt_ctf_field_type_integer *integer;
 468
 469         if (!type || type->frozen ||
 470                 type->declaration->id != CTF_TYPE_INTEGER) {
 471                 ret = -1;
 472                 goto end;
 473         }
 474
 475         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 476         integer->declaration.signedness = !!is_signed;
 477 end:
 478         return ret;
 479 }
 480
 481 enum bt_ctf_integer_base bt_ctf_field_type_integer_get_base(
 482                 struct bt_ctf_field_type *type)
 483 {
 484         enum bt_ctf_integer_base ret = BT_CTF_INTEGER_BASE_UNKNOWN;
 485         struct bt_ctf_field_type_integer *integer;
 486
 487         if (!type || type->declaration->id != CTF_TYPE_INTEGER) {
 488                 goto end;
 489         }
 490
 491         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 492         ret = integer->declaration.base;
 493 end:
 494         return ret;
 495 }
 496
 497 int bt_ctf_field_type_integer_set_base(struct bt_ctf_field_type *type,
 498                 enum bt_ctf_integer_base base)
 499 {
 500         int ret = 0;
 501
 502         if (!type || type->frozen ||
 503                 type->declaration->id != CTF_TYPE_INTEGER) {
 504                 ret = -1;
 505                 goto end;
 506         }
 507
 508         switch (base) {
 509         case BT_CTF_INTEGER_BASE_BINARY:
 510         case BT_CTF_INTEGER_BASE_OCTAL:
 511         case BT_CTF_INTEGER_BASE_DECIMAL:
 512         case BT_CTF_INTEGER_BASE_HEXADECIMAL:
 513         {
 514                 struct bt_ctf_field_type_integer *integer = container_of(type,
 515                         struct bt_ctf_field_type_integer, parent);
 516                 integer->declaration.base = base;
 517                 break;
 518         }
 519         default:
 520                 ret = -1;
 521         }
 522 end:
 523         return ret;
 524 }
 525
 526 enum ctf_string_encoding bt_ctf_field_type_integer_get_encoding(
 527                 struct bt_ctf_field_type *type)
 528 {
 529         enum ctf_string_encoding ret = CTF_STRING_UNKNOWN;
 530         struct bt_ctf_field_type_integer *integer;
 531
 532         if (!type || type->declaration->id != CTF_TYPE_INTEGER) {
 533                 goto end;
 534         }
 535
 536         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 537         ret = integer->declaration.encoding;
 538 end:
 539         return ret;
 540 }
 541
 542 int bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *type,
 543                 enum ctf_string_encoding encoding)
 544 {
 545         int ret = 0;
 546         struct bt_ctf_field_type_integer *integer;
 547
 548         if (!type || type->frozen ||
 549                 (type->declaration->id != CTF_TYPE_INTEGER) ||
 550                 (encoding < CTF_STRING_NONE) ||
 551                 (encoding >= CTF_STRING_UNKNOWN)) {
 552                 ret = -1;
 553                 goto end;
 554         }
 555
 556         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 557         integer->declaration.encoding = encoding;
 558 end:
 559         return ret;
 560 }
 561
 562 struct bt_ctf_clock *bt_ctf_field_type_integer_get_mapped_clock(
 563                 struct bt_ctf_field_type *type)
 564 {
 565         struct bt_ctf_field_type_integer *integer;
 566         struct bt_ctf_clock *clock = NULL;
 567
 568         if (!type) {
 569                 goto end;
 570         }
 571
 572         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 573         clock = integer->mapped_clock;
 574         bt_get(clock);
 575 end:
 576         return clock;
 577 }
 578
 579 int bt_ctf_field_type_integer_set_mapped_clock(
 580                 struct bt_ctf_field_type *type,
 581                 struct bt_ctf_clock *clock)
 582 {
 583         struct bt_ctf_field_type_integer *integer;
 584         int ret = 0;
 585
 586         if (!type || type->frozen) {
 587                 ret = -1;
 588                 goto end;
 589         }
 590
 591         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
 592         bt_put(integer->mapped_clock);
 593         bt_get(clock);
 594         integer->mapped_clock = clock;
 595 end:
 596         return ret;
 597 }
 598
 599 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_create(
 600                 struct bt_ctf_field_type *integer_container_type)
 601 {
 602         struct bt_ctf_field_type_enumeration *enumeration = NULL;
 603
 604         if (!integer_container_type) {
 605                 goto error;
 606         }
 607
 608         if (integer_container_type->declaration->id != CTF_TYPE_INTEGER) {
 609                 goto error;
 610         }
 611
 612         enumeration = g_new0(struct bt_ctf_field_type_enumeration, 1);
 613         if (!enumeration) {
 614                 goto error;
 615         }
 616
 617         enumeration->parent.declaration = &enumeration->declaration.p;
 618         enumeration->parent.declaration->id = CTF_TYPE_ENUM;
 619         bt_get(integer_container_type);
 620         enumeration->container = integer_container_type;
 621         enumeration->entries = g_ptr_array_new_with_free_func(
 622                 (GDestroyNotify)destroy_enumeration_mapping);
 623         bt_ctf_field_type_init(&enumeration->parent, FALSE);
 624         return &enumeration->parent;
 625 error:
 626         g_free(enumeration);
 627         return NULL;
 628 }
 629
 630 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_get_container_type(
 631                 struct bt_ctf_field_type *type)
 632 {
 633         struct bt_ctf_field_type *container_type = NULL;
 634         struct bt_ctf_field_type_enumeration *enumeration_type;
 635
 636         if (!type) {
 637                 goto end;
 638         }
 639
 640         if (type->declaration->id != CTF_TYPE_ENUM) {
 641                 goto end;
 642         }
 643
 644         enumeration_type = container_of(type,
 645                 struct bt_ctf_field_type_enumeration, parent);
 646         container_type = enumeration_type->container;
 647         bt_get(container_type);
 648 end:
 649         return container_type;
 650 }
 651
 652 int bt_ctf_field_type_enumeration_add_mapping(
 653                 struct bt_ctf_field_type *type, const char *string,
 654                 int64_t range_start, int64_t range_end)
 655 {
 656         int ret = 0;
 657         GQuark mapping_name;
 658         struct enumeration_mapping *mapping;
 659         struct bt_ctf_field_type_enumeration *enumeration;
 660         struct range_overlap_query query;
 661         char *escaped_string;
 662
 663         if (!type || (type->declaration->id != CTF_TYPE_ENUM) ||
 664                 type->frozen ||
 665                 (range_end < range_start)) {
 666                 ret = -1;
 667                 goto end;
 668         }
 669
 670         if (!string || strlen(string) == 0) {
 671                 ret = -1;
 672                 goto end;
 673         }
 674
 675         escaped_string = g_strescape(string, NULL);
 676         if (!escaped_string) {
 677                 ret = -1;
 678                 goto end;
 679         }
 680
 681         mapping_name = g_quark_from_string(escaped_string);
 682         query = (struct range_overlap_query) {
 683                 .range_start._signed = range_start,
 684                 .range_end._signed = range_end,
 685                 .mapping_name = mapping_name,
 686                 .overlaps = 0 };
 687         enumeration = container_of(type, struct bt_ctf_field_type_enumeration,
 688                 parent);
 689
 690         /* Check that the range does not overlap with one already present */
 691         g_ptr_array_foreach(enumeration->entries, check_ranges_overlap, &query);
 692         if (query.overlaps) {
 693                 ret = -1;
 694                 goto error_free;
 695         }
 696
 697         mapping = g_new(struct enumeration_mapping, 1);
 698         if (!mapping) {
 699                 ret = -1;
 700                 goto error_free;
 701         }
 702
 703         *mapping = (struct enumeration_mapping) {
 704                 .range_start._signed = range_start,
 705                 .range_end._signed = range_end, .string = mapping_name};
 706         g_ptr_array_add(enumeration->entries, mapping);
 707         g_ptr_array_sort(enumeration->entries,
 708                 (GCompareFunc)compare_enumeration_mappings_signed);
 709 error_free:
 710         free(escaped_string);
 711 end:
 712         return ret;
 713 }
 714
 715 int bt_ctf_field_type_enumeration_add_mapping_unsigned(
 716                 struct bt_ctf_field_type *type, const char *string,
 717                 uint64_t range_start, uint64_t range_end)
 718 {
 719         int ret = 0;
 720         GQuark mapping_name;
 721         struct enumeration_mapping *mapping;
 722         struct bt_ctf_field_type_enumeration *enumeration;
 723         struct range_overlap_query query;
 724         char *escaped_string;
 725
 726         if (!type || (type->declaration->id != CTF_TYPE_ENUM) ||
 727                 type->frozen ||
 728                 (range_end < range_start)) {
 729                 ret = -1;
 730                 goto end;
 731         }
 732
 733         if (!string || strlen(string) == 0) {
 734                 ret = -1;
 735                 goto end;
 736         }
 737
 738         escaped_string = g_strescape(string, NULL);
 739         if (!escaped_string) {
 740                 ret = -1;
 741                 goto end;
 742         }
 743
 744         mapping_name = g_quark_from_string(escaped_string);
 745         query = (struct range_overlap_query) {
 746                 .range_start._unsigned = range_start,
 747                 .range_end._unsigned = range_end,
 748                 .mapping_name = mapping_name,
 749                 .overlaps = 0 };
 750         enumeration = container_of(type, struct bt_ctf_field_type_enumeration,
 751                 parent);
 752
 753         /* Check that the range does not overlap with one already present */
 754         g_ptr_array_foreach(enumeration->entries, check_ranges_overlap_unsigned,
 755                 &query);
 756         if (query.overlaps) {
 757                 ret = -1;
 758                 goto error_free;
 759         }
 760
 761         mapping = g_new(struct enumeration_mapping, 1);
 762         if (!mapping) {
 763                 ret = -1;
 764                 goto error_free;
 765         }
 766
 767         *mapping = (struct enumeration_mapping) {
 768                 .range_start._unsigned = range_start,
 769                 .range_end._unsigned = range_end, .string = mapping_name};
 770         g_ptr_array_add(enumeration->entries, mapping);
 771         g_ptr_array_sort(enumeration->entries,
 772                 (GCompareFunc)compare_enumeration_mappings_unsigned);
 773 error_free:
 774         free(escaped_string);
 775 end:
 776         return ret;
 777 }
 778
 779 const char *bt_ctf_field_type_enumeration_get_mapping_name_unsigned(
 780                 struct bt_ctf_field_type_enumeration *enumeration_type,
 781                 uint64_t value)
 782 {
 783         const char *name = NULL;
 784         struct range_overlap_query query =
 785                 (struct range_overlap_query) {
 786                 .range_start._unsigned = value,
 787                 .range_end._unsigned = value,
 788                 .overlaps = 0 };
 789
 790         g_ptr_array_foreach(enumeration_type->entries,
 791                 check_ranges_overlap_unsigned,
 792                 &query);
 793         if (!query.overlaps) {
 794                 goto end;
 795         }
 796
 797         name = g_quark_to_string(query.mapping_name);
 798 end:
 799         return name;
 800 }
 801
 802 const char *bt_ctf_field_type_enumeration_get_mapping_name_signed(
 803                 struct bt_ctf_field_type_enumeration *enumeration_type,
 804                 int64_t value)
 805 {
 806         const char *name = NULL;
 807         struct range_overlap_query query =
 808                 (struct range_overlap_query) {
 809                 .range_start._signed = value,
 810                 .range_end._signed = value,
 811                 .overlaps = 0 };
 812
 813         g_ptr_array_foreach(enumeration_type->entries, check_ranges_overlap,
 814                 &query);
 815         if (!query.overlaps) {
 816                 goto end;
 817         }
 818
 819         name = g_quark_to_string(query.mapping_name);
 820 end:
 821         return name;
 822 }
 823
 824 int bt_ctf_field_type_enumeration_get_mapping_count(
 825                 struct bt_ctf_field_type *type)
 826 {
 827         int ret = 0;
 828         struct bt_ctf_field_type_enumeration *enumeration;
 829
 830         if (!type || (type->declaration->id != CTF_TYPE_ENUM)) {
 831                 ret = -1;
 832                 goto end;
 833         }
 834
 835         enumeration = container_of(type, struct bt_ctf_field_type_enumeration,
 836                 parent);
 837         ret = (int) enumeration->entries->len;
 838 end:
 839         return ret;
 840 }
 841
 842 static inline
 843 struct enumeration_mapping *get_enumeration_mapping(
 844         struct bt_ctf_field_type *type, int index)
 845 {
 846         struct enumeration_mapping *mapping = NULL;
 847         struct bt_ctf_field_type_enumeration *enumeration;
 848
 849         enumeration = container_of(type, struct bt_ctf_field_type_enumeration,
 850                 parent);
 851         if (index >= enumeration->entries->len) {
 852                 goto end;
 853         }
 854
 855         mapping = g_ptr_array_index(enumeration->entries, index);
 856 end:
 857         return mapping;
 858 }
 859
 860 int bt_ctf_field_type_enumeration_get_mapping(
 861                 struct bt_ctf_field_type *type, int index,
 862                 const char **string, int64_t *range_start, int64_t *range_end)
 863 {
 864         struct enumeration_mapping *mapping;
 865         int ret = 0;
 866
 867         if (!type || index < 0 || !string || !range_start || !range_end ||
 868                 (type->declaration->id != CTF_TYPE_ENUM)) {
 869                 ret = -1;
 870                 goto end;
 871         }
 872
 873         mapping = get_enumeration_mapping(type, index);
 874         if (!mapping) {
 875                 ret = -1;
 876                 goto end;
 877         }
 878
 879         *string = g_quark_to_string(mapping->string);
 880         *range_start = mapping->range_start._signed;
 881         *range_end = mapping->range_end._signed;
 882 end:
 883         return ret;
 884 }
 885
 886 int bt_ctf_field_type_enumeration_get_mapping_unsigned(
 887                 struct bt_ctf_field_type *type, int index,
 888                 const char **string, uint64_t *range_start, uint64_t *range_end)
 889 {
 890         struct enumeration_mapping *mapping;
 891         int ret = 0;
 892
 893         if (!type || index < 0 || !string || !range_start || !range_end ||
 894                 (type->declaration->id != CTF_TYPE_ENUM)) {
 895                 ret = -1;
 896                 goto end;
 897         }
 898
 899         mapping = get_enumeration_mapping(type, index);
 900         if (!mapping) {
 901                 ret = -1;
 902                 goto end;
 903         }
 904
 905         *string = g_quark_to_string(mapping->string);
 906         *range_start = mapping->range_start._unsigned;
 907         *range_end = mapping->range_end._unsigned;
 908 end:
 909         return ret;
 910 }
 911
 912 int bt_ctf_field_type_enumeration_get_mapping_index_by_name(
 913                 struct bt_ctf_field_type *type, const char *name)
 914 {
 915         GQuark name_quark;
 916         struct bt_ctf_field_type_enumeration *enumeration;
 917         int i, ret = 0;
 918
 919         if (!type || !name ||
 920                 (type->declaration->id != CTF_TYPE_ENUM)) {
 921                 ret = -1;
 922                 goto end;
 923         }
 924
 925         name_quark = g_quark_try_string(name);
 926         if (!name_quark) {
 927                 ret = -1;
 928                 goto end;
 929         }
 930
 931         enumeration = container_of(type,
 932                 struct bt_ctf_field_type_enumeration, parent);
 933         for (i = 0; i < enumeration->entries->len; i++) {
 934                 struct enumeration_mapping *mapping =
 935                         get_enumeration_mapping(type, i);
 936
 937                 if (mapping->string == name_quark) {
 938                         ret = i;
 939                         goto end;
 940                 }
 941         }
 942
 943         ret = -1;
 944 end:
 945         return ret;
 946 }
 947
 948 int bt_ctf_field_type_enumeration_get_mapping_index_by_value(
 949                 struct bt_ctf_field_type *type, int64_t value)
 950 {
 951         struct bt_ctf_field_type_enumeration *enumeration;
 952         int i, ret = 0;
 953
 954         if (!type || (type->declaration->id != CTF_TYPE_ENUM)) {
 955                 ret = -1;
 956                 goto end;
 957         }
 958
 959         enumeration = container_of(type,
 960                 struct bt_ctf_field_type_enumeration, parent);
 961         for (i = 0; i < enumeration->entries->len; i++) {
 962                 struct enumeration_mapping *mapping =
 963                         get_enumeration_mapping(type, i);
 964
 965                 if (value >= mapping->range_start._signed &&
 966                         value <= mapping->range_end._signed) {
 967                         ret = i;
 968                         goto end;
 969                 }
 970         }
 971
 972         ret = -1;
 973 end:
 974         return ret;
 975 }
 976
 977 int bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(
 978                 struct bt_ctf_field_type *type, uint64_t value)
 979 {
 980         struct bt_ctf_field_type_enumeration *enumeration;
 981         int i, ret = 0;
 982
 983         if (!type || (type->declaration->id != CTF_TYPE_ENUM)) {
 984                 ret = -1;
 985                 goto end;
 986         }
 987
 988         enumeration = container_of(type,
 989                 struct bt_ctf_field_type_enumeration, parent);
 990         for (i = 0; i < enumeration->entries->len; i++) {
 991                 struct enumeration_mapping *mapping =
 992                         get_enumeration_mapping(type, i);
 993
 994                 if (value >= mapping->range_start._unsigned &&
 995                         value <= mapping->range_end._unsigned) {
 996                         ret = i;
 997                         goto end;
 998                 }
 999         }
1000
1001         ret = -1;
1002 end:
1003         return ret;
1004 }
1005
1006 struct bt_ctf_field_type *bt_ctf_field_type_floating_point_create(void)
1007 {
1008         struct bt_ctf_field_type_floating_point *floating_point =
1009                 g_new0(struct bt_ctf_field_type_floating_point, 1);
1010
1011         if (!floating_point) {
1012                 goto end;
1013         }
1014
1015         floating_point->declaration.sign = &floating_point->sign;
1016         floating_point->declaration.mantissa = &floating_point->mantissa;
1017         floating_point->declaration.exp = &floating_point->exp;
1018         floating_point->sign.len = 1;
1019         floating_point->parent.declaration = &floating_point->declaration.p;
1020         floating_point->parent.declaration->id = CTF_TYPE_FLOAT;
1021         floating_point->declaration.exp->len =
1022                 sizeof(float) * CHAR_BIT - FLT_MANT_DIG;
1023         floating_point->declaration.mantissa->len = FLT_MANT_DIG - 1;
1024         floating_point->sign.p.alignment = 1;
1025         floating_point->mantissa.p.alignment = 1;
1026         floating_point->exp.p.alignment = 1;
1027
1028         bt_ctf_field_type_init(&floating_point->parent, TRUE);
1029 end:
1030         return floating_point ? &floating_point->parent : NULL;
1031 }
1032
1033 int bt_ctf_field_type_floating_point_get_exponent_digits(
1034                 struct bt_ctf_field_type *type)
1035 {
1036         int ret = 0;
1037         struct bt_ctf_field_type_floating_point *floating_point;
1038
1039         if (!type || (type->declaration->id != CTF_TYPE_FLOAT)) {
1040                 ret = -1;
1041                 goto end;
1042         }
1043
1044         floating_point = container_of(type,
1045                 struct bt_ctf_field_type_floating_point, parent);
1046         ret = (int) floating_point->declaration.exp->len;
1047 end:
1048         return ret;
1049 }
1050
1051 int bt_ctf_field_type_floating_point_set_exponent_digits(
1052                 struct bt_ctf_field_type *type,
1053                 unsigned int exponent_digits)
1054 {
1055         int ret = 0;
1056         struct bt_ctf_field_type_floating_point *floating_point;
1057
1058         if (!type || type->frozen ||
1059                 (type->declaration->id != CTF_TYPE_FLOAT)) {
1060                 ret = -1;
1061                 goto end;
1062         }
1063
1064         floating_point = container_of(type,
1065                 struct bt_ctf_field_type_floating_point, parent);
1066         if ((exponent_digits != sizeof(float) * CHAR_BIT - FLT_MANT_DIG) &&
1067                 (exponent_digits != sizeof(double) * CHAR_BIT - DBL_MANT_DIG) &&
1068                 (exponent_digits !=
1069                         sizeof(long double) * CHAR_BIT - LDBL_MANT_DIG)) {
1070                 ret = -1;
1071                 goto end;
1072         }
1073
1074         floating_point->declaration.exp->len = exponent_digits;
1075 end:
1076         return ret;
1077 }
1078
1079 int bt_ctf_field_type_floating_point_get_mantissa_digits(
1080                 struct bt_ctf_field_type *type)
1081 {
1082         int ret = 0;
1083         struct bt_ctf_field_type_floating_point *floating_point;
1084
1085         if (!type || (type->declaration->id != CTF_TYPE_FLOAT)) {
1086                 ret = -1;
1087                 goto end;
1088         }
1089
1090         floating_point = container_of(type,
1091                 struct bt_ctf_field_type_floating_point, parent);
1092         ret = (int) floating_point->mantissa.len + 1;
1093 end:
1094         return ret;
1095 }
1096
1097 int bt_ctf_field_type_floating_point_set_mantissa_digits(
1098                 struct bt_ctf_field_type *type,
1099                 unsigned int mantissa_digits)
1100 {
1101         int ret = 0;
1102         struct bt_ctf_field_type_floating_point *floating_point;
1103
1104         if (!type || type->frozen ||
1105                 (type->declaration->id != CTF_TYPE_FLOAT)) {
1106                 ret = -1;
1107                 goto end;
1108         }
1109
1110         floating_point = container_of(type,
1111                 struct bt_ctf_field_type_floating_point, parent);
1112
1113         if ((mantissa_digits != FLT_MANT_DIG) &&
1114                 (mantissa_digits != DBL_MANT_DIG) &&
1115                 (mantissa_digits != LDBL_MANT_DIG)) {
1116                 ret = -1;
1117                 goto end;
1118         }
1119
1120         floating_point->declaration.mantissa->len = mantissa_digits - 1;
1121 end:
1122         return ret;
1123 }
1124
1125 struct bt_ctf_field_type *bt_ctf_field_type_structure_create(void)
1126 {
1127         struct bt_ctf_field_type_structure *structure =
1128                 g_new0(struct bt_ctf_field_type_structure, 1);
1129
1130         if (!structure) {
1131                 goto error;
1132         }
1133
1134         structure->parent.declaration = &structure->declaration.p;
1135         structure->parent.declaration->id = CTF_TYPE_STRUCT;
1136         structure->fields = g_ptr_array_new_with_free_func(
1137                 (GDestroyNotify)destroy_structure_field);
1138         structure->field_name_to_index = g_hash_table_new(NULL, NULL);
1139         bt_ctf_field_type_init(&structure->parent, TRUE);
1140         return &structure->parent;
1141 error:
1142         return NULL;
1143 }
1144
1145 int bt_ctf_field_type_structure_add_field(struct bt_ctf_field_type *type,
1146                 struct bt_ctf_field_type *field_type,
1147                 const char *field_name)
1148 {
1149         int ret = 0;
1150         struct bt_ctf_field_type_structure *structure;
1151
1152         if (!type || !field_type || type->frozen ||
1153                 bt_ctf_validate_identifier(field_name) ||
1154                 (type->declaration->id != CTF_TYPE_STRUCT) ||
1155                 bt_ctf_field_type_validate(field_type)) {
1156                 ret = -1;
1157                 goto end;
1158         }
1159
1160         structure = container_of(type,
1161                 struct bt_ctf_field_type_structure, parent);
1162         if (add_structure_field(structure->fields,
1163                 structure->field_name_to_index, field_type, field_name)) {
1164                 ret = -1;
1165                 goto end;
1166         }
1167 end:
1168         return ret;
1169 }
1170
1171 int bt_ctf_field_type_structure_get_field_count(
1172                 struct bt_ctf_field_type *type)
1173 {
1174         int ret = 0;
1175         struct bt_ctf_field_type_structure *structure;
1176
1177         if (!type || (type->declaration->id != CTF_TYPE_STRUCT)) {
1178                 ret = -1;
1179                 goto end;
1180         }
1181
1182         structure = container_of(type, struct bt_ctf_field_type_structure,
1183                 parent);
1184         ret = (int) structure->fields->len;
1185 end:
1186         return ret;
1187 }
1188
1189 int bt_ctf_field_type_structure_get_field(struct bt_ctf_field_type *type,
1190                 const char **field_name, struct bt_ctf_field_type **field_type,
1191                 int index)
1192 {
1193         struct bt_ctf_field_type_structure *structure;
1194         struct structure_field *field;
1195         int ret = 0;
1196
1197         if (!type || index < 0 || (type->declaration->id != CTF_TYPE_STRUCT)) {
1198                 ret = -1;
1199                 goto end;
1200         }
1201
1202         structure = container_of(type, struct bt_ctf_field_type_structure,
1203                 parent);
1204         if (index >= structure->fields->len) {
1205                 ret = -1;
1206                 goto end;
1207         }
1208
1209         field = g_ptr_array_index(structure->fields, index);
1210         if (field_type) {
1211                 *field_type = field->type;
1212                 bt_get(field->type);
1213         }
1214         if (field_name) {
1215                 *field_name = g_quark_to_string(field->name);
1216         }
1217 end:
1218         return ret;
1219 }
1220
1221 struct bt_ctf_field_type *bt_ctf_field_type_structure_get_field_type_by_name(
1222                 struct bt_ctf_field_type *type,
1223                 const char *name)
1224 {
1225         size_t index;
1226         GQuark name_quark;
1227         struct structure_field *field;
1228         struct bt_ctf_field_type_structure *structure;
1229         struct bt_ctf_field_type *field_type = NULL;
1230
1231         if (!type || !name) {
1232                 goto end;
1233         }
1234
1235         name_quark = g_quark_try_string(name);
1236         if (!name_quark) {
1237                 goto end;
1238         }
1239
1240         structure = container_of(type, struct bt_ctf_field_type_structure,
1241                 parent);
1242         if (!g_hash_table_lookup_extended(structure->field_name_to_index,
1243                 GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
1244                 goto end;
1245         }
1246
1247         field = structure->fields->pdata[index];
1248         field_type = field->type;
1249         bt_get(field_type);
1250 end:
1251         return field_type;
1252 }
1253
1254 struct bt_ctf_field_type *bt_ctf_field_type_variant_create(
1255         struct bt_ctf_field_type *enum_tag, const char *tag_name)
1256 {
1257         struct bt_ctf_field_type_variant *variant = NULL;
1258
1259         if (tag_name && bt_ctf_validate_identifier(tag_name)) {
1260                 goto error;
1261         }
1262
1263         variant = g_new0(struct bt_ctf_field_type_variant, 1);
1264         if (!variant) {
1265                 goto error;
1266         }
1267
1268         variant->parent.declaration = &variant->declaration.p;
1269         variant->parent.declaration->id = CTF_TYPE_VARIANT;
1270         variant->tag_name = g_string_new(tag_name);
1271         variant->field_name_to_index = g_hash_table_new(NULL, NULL);
1272         variant->fields = g_ptr_array_new_with_free_func(
1273                 (GDestroyNotify) destroy_structure_field);
1274         if (enum_tag) {
1275                 bt_get(enum_tag);
1276                 variant->tag = container_of(enum_tag,
1277                         struct bt_ctf_field_type_enumeration, parent);
1278         }
1279
1280         bt_ctf_field_type_init(&variant->parent, TRUE);
1281         /* A variant's alignment is undefined */
1282         variant->parent.declaration->alignment = 0;
1283         return &variant->parent;
1284 error:
1285         return NULL;
1286 }
1287
1288 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_tag_type(
1289                 struct bt_ctf_field_type *type)
1290 {
1291         struct bt_ctf_field_type_variant *variant;
1292         struct bt_ctf_field_type *tag_type = NULL;
1293
1294         if (!type || (type->declaration->id != CTF_TYPE_VARIANT)) {
1295                 goto end;
1296         }
1297
1298         variant = container_of(type, struct bt_ctf_field_type_variant, parent);
1299         if (!variant->tag) {
1300                 goto end;
1301         }
1302
1303         tag_type = &variant->tag->parent;
1304         bt_get(tag_type);
1305 end:
1306         return tag_type;
1307 }
1308
1309 const char *bt_ctf_field_type_variant_get_tag_name(
1310                 struct bt_ctf_field_type *type)
1311 {
1312         struct bt_ctf_field_type_variant *variant;
1313         const char *tag_name = NULL;
1314
1315         if (!type || (type->declaration->id != CTF_TYPE_VARIANT)) {
1316                 goto end;
1317         }
1318
1319         variant = container_of(type, struct bt_ctf_field_type_variant, parent);
1320         if (variant->tag_name->len == 0) {
1321                 goto end;
1322         }
1323
1324         tag_name = variant->tag_name->str;
1325 end:
1326         return tag_name;
1327 }
1328
1329 int bt_ctf_field_type_variant_set_tag_name(
1330                 struct bt_ctf_field_type *type, const char *name)
1331 {
1332         int ret = 0;
1333         struct bt_ctf_field_type_variant *variant;
1334
1335         if (!type || type->frozen ||
1336                 (type->declaration->id != CTF_TYPE_VARIANT) ||
1337                 bt_ctf_validate_identifier(name)) {
1338                 ret = -1;
1339                 goto end;
1340         }
1341
1342         variant = container_of(type, struct bt_ctf_field_type_variant, parent);
1343         g_string_assign(variant->tag_name, name);
1344 end:
1345         return ret;
1346 }
1347
1348 int bt_ctf_field_type_variant_add_field(struct bt_ctf_field_type *type,
1349                 struct bt_ctf_field_type *field_type,
1350                 const char *field_name)
1351 {
1352         size_t i;
1353         int ret = 0;
1354         struct bt_ctf_field_type_variant *variant;
1355         GQuark field_name_quark = g_quark_from_string(field_name);
1356
1357         if (!type || !field_type || type->frozen ||
1358                 bt_ctf_validate_identifier(field_name) ||
1359                 (type->declaration->id != CTF_TYPE_VARIANT) ||
1360                 bt_ctf_field_type_validate(field_type)) {
1361                 ret = -1;
1362                 goto end;
1363         }
1364
1365         variant = container_of(type, struct bt_ctf_field_type_variant, parent);
1366
1367         /* The user has explicitly provided a tag; validate against it. */
1368         if (variant->tag) {
1369                 int name_found = 0;
1370
1371                 /* Make sure this name is present in the enum tag */
1372                 for (i = 0; i < variant->tag->entries->len; i++) {
1373                         struct enumeration_mapping *mapping =
1374                                 g_ptr_array_index(variant->tag->entries, i);
1375
1376                         if (mapping->string == field_name_quark) {
1377                                 name_found = 1;
1378                                 break;
1379                         }
1380                 }
1381
1382                 if (!name_found) {
1383                         /* Validation failed */
1384                         ret = -1;
1385                         goto end;
1386                 }
1387         }
1388
1389         if (add_structure_field(variant->fields, variant->field_name_to_index,
1390                 field_type, field_name)) {
1391                 ret = -1;
1392                 goto end;
1393         }
1394 end:
1395         return ret;
1396 }
1397
1398 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_by_name(
1399                 struct bt_ctf_field_type *type,
1400                 const char *field_name)
1401 {
1402         size_t index;
1403         GQuark name_quark;
1404         struct structure_field *field;
1405         struct bt_ctf_field_type_variant *variant;
1406         struct bt_ctf_field_type *field_type = NULL;
1407
1408         if (!type || !field_name) {
1409                 goto end;
1410         }
1411
1412         name_quark = g_quark_try_string(field_name);
1413         if (!name_quark) {
1414                 goto end;
1415         }
1416
1417         variant = container_of(type, struct bt_ctf_field_type_variant, parent);
1418         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
1419                 GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
1420                 goto end;
1421         }
1422
1423         field = g_ptr_array_index(variant->fields, index);
1424         field_type = field->type;
1425         bt_get(field_type);
1426 end:
1427         return field_type;
1428 }
1429
1430 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_from_tag(
1431                 struct bt_ctf_field_type *type,
1432                 struct bt_ctf_field *tag)
1433 {
1434         const char *enum_value;
1435         struct bt_ctf_field_type *field_type = NULL;
1436
1437         if (!type || !tag || type->declaration->id != CTF_TYPE_VARIANT) {
1438                 goto end;
1439         }
1440
1441         enum_value = bt_ctf_field_enumeration_get_mapping_name(tag);
1442         if (!enum_value) {
1443                 goto end;
1444         }
1445
1446         /* Already increments field_type's reference count */
1447         field_type = bt_ctf_field_type_variant_get_field_type_by_name(
1448                 type, enum_value);
1449 end:
1450         return field_type;
1451 }
1452
1453 int bt_ctf_field_type_variant_get_field_count(struct bt_ctf_field_type *type)
1454 {
1455         int ret = 0;
1456         struct bt_ctf_field_type_variant *variant;
1457
1458         if (!type || (type->declaration->id != CTF_TYPE_VARIANT)) {
1459                 ret = -1;
1460                 goto end;
1461         }
1462
1463         variant = container_of(type, struct bt_ctf_field_type_variant,
1464                 parent);
1465         ret = (int) variant->fields->len;
1466 end:
1467         return ret;
1468
1469 }
1470
1471 int bt_ctf_field_type_variant_get_field(struct bt_ctf_field_type *type,
1472                 const char **field_name, struct bt_ctf_field_type **field_type,
1473                 int index)
1474 {
1475         struct bt_ctf_field_type_variant *variant;
1476         struct structure_field *field;
1477         int ret = 0;
1478
1479         if (!type || index < 0 || (type->declaration->id != CTF_TYPE_VARIANT)) {
1480                 ret = -1;
1481                 goto end;
1482         }
1483
1484         variant = container_of(type, struct bt_ctf_field_type_variant,
1485                 parent);
1486         if (index >= variant->fields->len) {
1487                 ret = -1;
1488                 goto end;
1489         }
1490
1491         field = g_ptr_array_index(variant->fields, index);
1492         if (field_type) {
1493                 *field_type = field->type;
1494                 bt_get(field->type);
1495         }
1496         if (field_name) {
1497                 *field_name = g_quark_to_string(field->name);
1498         }
1499 end:
1500         return ret;
1501 }
1502
1503 struct bt_ctf_field_type *bt_ctf_field_type_array_create(
1504                 struct bt_ctf_field_type *element_type,
1505                 unsigned int length)
1506 {
1507         struct bt_ctf_field_type_array *array = NULL;
1508
1509         if (!element_type || length == 0 ||
1510                 bt_ctf_field_type_validate(element_type)) {
1511                 goto error;
1512         }
1513
1514         array = g_new0(struct bt_ctf_field_type_array, 1);
1515         if (!array) {
1516                 goto error;
1517         }
1518
1519         array->parent.declaration = &array->declaration.p;
1520         array->parent.declaration->id = CTF_TYPE_ARRAY;
1521
1522         bt_get(element_type);
1523         array->element_type = element_type;
1524         array->length = length;
1525         bt_ctf_field_type_init(&array->parent, FALSE);
1526         return &array->parent;
1527 error:
1528         return NULL;
1529 }
1530
1531 struct bt_ctf_field_type *bt_ctf_field_type_array_get_element_type(
1532                 struct bt_ctf_field_type *type)
1533 {
1534         struct bt_ctf_field_type *ret = NULL;
1535         struct bt_ctf_field_type_array *array;
1536
1537         if (!type || (type->declaration->id != CTF_TYPE_ARRAY)) {
1538                 goto end;
1539         }
1540
1541         array = container_of(type, struct bt_ctf_field_type_array, parent);
1542         ret = array->element_type;
1543         bt_get(ret);
1544 end:
1545         return ret;
1546 }
1547
1548 int64_t bt_ctf_field_type_array_get_length(struct bt_ctf_field_type *type)
1549 {
1550         int64_t ret;
1551         struct bt_ctf_field_type_array *array;
1552
1553         if (!type || (type->declaration->id != CTF_TYPE_ARRAY)) {
1554                 ret = -1;
1555                 goto end;
1556         }
1557
1558         array = container_of(type, struct bt_ctf_field_type_array, parent);
1559         ret = (int64_t) array->length;
1560 end:
1561         return ret;
1562 }
1563
1564 struct bt_ctf_field_type *bt_ctf_field_type_sequence_create(
1565                 struct bt_ctf_field_type *element_type,
1566                 const char *length_field_name)
1567 {
1568         struct bt_ctf_field_type_sequence *sequence = NULL;
1569
1570         if (!element_type || bt_ctf_validate_identifier(length_field_name) ||
1571                 bt_ctf_field_type_validate(element_type)) {
1572                 goto error;
1573         }
1574
1575         sequence = g_new0(struct bt_ctf_field_type_sequence, 1);
1576         if (!sequence) {
1577                 goto error;
1578         }
1579
1580         sequence->parent.declaration = &sequence->declaration.p;
1581         sequence->parent.declaration->id = CTF_TYPE_SEQUENCE;
1582         bt_get(element_type);
1583         sequence->element_type = element_type;
1584         sequence->length_field_name = g_string_new(length_field_name);
1585         bt_ctf_field_type_init(&sequence->parent, FALSE);
1586         return &sequence->parent;
1587 error:
1588         return NULL;
1589 }
1590
1591 struct bt_ctf_field_type *bt_ctf_field_type_sequence_get_element_type(
1592                 struct bt_ctf_field_type *type)
1593 {
1594         struct bt_ctf_field_type *ret = NULL;
1595         struct bt_ctf_field_type_sequence *sequence;
1596
1597         if (!type || (type->declaration->id != CTF_TYPE_SEQUENCE)) {
1598                 goto end;
1599         }
1600
1601         sequence = container_of(type, struct bt_ctf_field_type_sequence,
1602                 parent);
1603         ret = sequence->element_type;
1604         bt_get(ret);
1605 end:
1606         return ret;
1607 }
1608
1609 const char *bt_ctf_field_type_sequence_get_length_field_name(
1610                 struct bt_ctf_field_type *type)
1611 {
1612         const char *ret = NULL;
1613         struct bt_ctf_field_type_sequence *sequence;
1614
1615         if (!type || (type->declaration->id != CTF_TYPE_SEQUENCE)) {
1616                 goto end;
1617         }
1618
1619         sequence = container_of(type, struct bt_ctf_field_type_sequence,
1620                 parent);
1621         ret = sequence->length_field_name->str;
1622 end:
1623         return ret;
1624 }
1625
1626 struct bt_ctf_field_type *bt_ctf_field_type_string_create(void)
1627 {
1628         struct bt_ctf_field_type_string *string =
1629                 g_new0(struct bt_ctf_field_type_string, 1);
1630
1631         if (!string) {
1632                 return NULL;
1633         }
1634
1635         string->parent.declaration = &string->declaration.p;
1636         string->parent.declaration->id = CTF_TYPE_STRING;
1637         bt_ctf_field_type_init(&string->parent, TRUE);
1638         string->declaration.encoding = CTF_STRING_UTF8;
1639         string->parent.declaration->alignment = CHAR_BIT;
1640         return &string->parent;
1641 }
1642
1643 enum ctf_string_encoding bt_ctf_field_type_string_get_encoding(
1644                 struct bt_ctf_field_type *type)
1645 {
1646         struct bt_ctf_field_type_string *string;
1647         enum ctf_string_encoding ret = CTF_STRING_UNKNOWN;
1648
1649         if (!type || (type->declaration->id != CTF_TYPE_STRING)) {
1650                 goto end;
1651         }
1652
1653         string = container_of(type, struct bt_ctf_field_type_string,
1654                 parent);
1655         ret = string->declaration.encoding;
1656 end:
1657         return ret;
1658 }
1659
1660 int bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *type,
1661                 enum ctf_string_encoding encoding)
1662 {
1663         int ret = 0;
1664         struct bt_ctf_field_type_string *string;
1665
1666         if (!type || type->declaration->id != CTF_TYPE_STRING ||
1667                 (encoding != CTF_STRING_UTF8 &&
1668                 encoding != CTF_STRING_ASCII)) {
1669                 ret = -1;
1670                 goto end;
1671         }
1672
1673         string = container_of(type, struct bt_ctf_field_type_string, parent);
1674         string->declaration.encoding = encoding;
1675 end:
1676         return ret;
1677 }
1678
1679 int bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type)
1680 {
1681         int ret;
1682         enum ctf_type_id type_id;
1683
1684         if (!type) {
1685                 ret = -1;
1686                 goto end;
1687         }
1688
1689         if (type->frozen) {
1690                 ret = (int) type->declaration->alignment;
1691                 goto end;
1692         }
1693
1694         type_id = bt_ctf_field_type_get_type_id(type);
1695         switch (type_id) {
1696         case CTF_TYPE_SEQUENCE:
1697         {
1698                 struct bt_ctf_field_type *element =
1699                         bt_ctf_field_type_sequence_get_element_type(type);
1700
1701                 if (!element) {
1702                         ret = -1;
1703                         goto end;
1704                 }
1705
1706                 ret = bt_ctf_field_type_get_alignment(element);
1707                 bt_put(element);
1708                 break;
1709         }
1710         case CTF_TYPE_ARRAY:
1711         {
1712                 struct bt_ctf_field_type *element =
1713                         bt_ctf_field_type_array_get_element_type(type);
1714
1715                 if (!element) {
1716                         ret = -1;
1717                         goto end;
1718                 }
1719
1720                 ret = bt_ctf_field_type_get_alignment(element);
1721                 bt_put(element);
1722                 break;
1723         }
1724         case CTF_TYPE_STRUCT:
1725         {
1726                 int i, element_count;
1727
1728                 element_count = bt_ctf_field_type_structure_get_field_count(
1729                         type);
1730                 if (element_count < 0) {
1731                         ret = element_count;
1732                         goto end;
1733                 }
1734
1735                 for (i = 0; i < element_count; i++) {
1736                         struct bt_ctf_field_type *field;
1737                         int field_alignment;
1738
1739                         ret = bt_ctf_field_type_structure_get_field(type, NULL,
1740                                 &field, i);
1741                         if (ret) {
1742                                 goto end;
1743                         }
1744
1745                         assert(field);
1746                         field_alignment = bt_ctf_field_type_get_alignment(
1747                                 field);
1748                         bt_put(field);
1749                         if (field_alignment < 0) {
1750                                 ret = field_alignment;
1751                                 goto end;
1752                         }
1753
1754                         type->declaration->alignment = MAX(field_alignment,
1755                                 type->declaration->alignment);
1756                 }
1757                 ret = (int) type->declaration->alignment;
1758                 break;
1759         }
1760         case CTF_TYPE_UNKNOWN:
1761                 ret = -1;
1762                 break;
1763         default:
1764                 ret = (int) type->declaration->alignment;
1765                 break;
1766         }
1767 end:
1768         return ret;
1769 }
1770
1771 static inline
1772 int is_power_of_two(unsigned int value)
1773 {
1774         return ((value & (value - 1)) == 0) && value > 0;
1775 }
1776
1777 int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type,
1778                 unsigned int alignment)
1779 {
1780         int ret = 0;
1781         enum ctf_type_id type_id;
1782
1783         /* Alignment must be a power of two */
1784         if (!type || type->frozen || !is_power_of_two(alignment)) {
1785                 ret = -1;
1786                 goto end;
1787         }
1788
1789         type_id = bt_ctf_field_type_get_type_id(type);
1790         if (type_id == CTF_TYPE_UNKNOWN) {
1791                 ret = -1;
1792                 goto end;
1793         }
1794
1795         if (type->declaration->id == CTF_TYPE_STRING &&
1796                 alignment != CHAR_BIT) {
1797                 ret = -1;
1798                 goto end;
1799         }
1800
1801         if (type_id == CTF_TYPE_VARIANT || type_id == CTF_TYPE_SEQUENCE ||
1802                 type_id == CTF_TYPE_ARRAY) {
1803                 /* Setting an alignment on these types makes no sense */
1804                 ret = -1;
1805                 goto end;
1806         }
1807
1808         type->declaration->alignment = alignment;
1809         ret = 0;
1810 end:
1811         return ret;
1812 }
1813
1814 enum bt_ctf_byte_order bt_ctf_field_type_get_byte_order(
1815                 struct bt_ctf_field_type *type)
1816 {
1817         enum bt_ctf_byte_order ret = BT_CTF_BYTE_ORDER_UNKNOWN;
1818         int internal_byte_order = -1;
1819
1820         if (!type) {
1821                 goto end;
1822         }
1823
1824         switch (type->declaration->id) {
1825         case CTF_TYPE_INTEGER:
1826         {
1827                 struct bt_ctf_field_type_integer *integer = container_of(
1828                         type, struct bt_ctf_field_type_integer, parent);
1829                 internal_byte_order = integer->declaration.byte_order;
1830                 break;
1831         }
1832         case CTF_TYPE_FLOAT:
1833         {
1834                 struct bt_ctf_field_type_floating_point *floating_point =
1835                         container_of(type,
1836                                 struct bt_ctf_field_type_floating_point,
1837                                 parent);
1838                 internal_byte_order = floating_point->declaration.byte_order;
1839                 break;
1840         }
1841         default:
1842                 goto end;
1843         }
1844
1845         switch (internal_byte_order) {
1846         case LITTLE_ENDIAN:
1847                 ret = BT_CTF_BYTE_ORDER_LITTLE_ENDIAN;
1848                 break;
1849         case BIG_ENDIAN:
1850                 ret = BT_CTF_BYTE_ORDER_BIG_ENDIAN;
1851                 break;
1852         case 0:
1853                 ret = BT_CTF_BYTE_ORDER_NATIVE;
1854                 break;
1855         default:
1856                 ret = BT_CTF_BYTE_ORDER_UNKNOWN;
1857         }
1858 end:
1859         return ret;
1860 }
1861
1862 int bt_ctf_field_type_set_byte_order(struct bt_ctf_field_type *type,
1863                 enum bt_ctf_byte_order byte_order)
1864 {
1865         int ret = 0;
1866         int internal_byte_order;
1867         enum ctf_type_id type_id;
1868
1869         if (!type || type->frozen) {
1870                 ret = -1;
1871                 goto end;
1872         }
1873
1874         switch (byte_order) {
1875         case BT_CTF_BYTE_ORDER_NATIVE:
1876                 /* Leave unset. Will be initialized by parent. */
1877                 internal_byte_order = 0;
1878                 break;
1879         case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
1880                 internal_byte_order = LITTLE_ENDIAN;
1881                 break;
1882         case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
1883         case BT_CTF_BYTE_ORDER_NETWORK:
1884                 internal_byte_order = BIG_ENDIAN;
1885                 break;
1886         default:
1887                 ret = -1;
1888                 goto end;
1889         }
1890
1891         type_id = type->declaration->id;
1892         if (set_byte_order_funcs[type_id]) {
1893                 set_byte_order_funcs[type_id](type, internal_byte_order, 0);
1894         }
1895 end:
1896         return ret;
1897 }
1898
1899 enum ctf_type_id bt_ctf_field_type_get_type_id(
1900                 struct bt_ctf_field_type *type)
1901 {
1902         if (!type) {
1903                 return CTF_TYPE_UNKNOWN;
1904         }
1905
1906         return type->declaration->id;
1907 }
1908
1909 int bt_ctf_field_type_is_integer(struct bt_ctf_field_type *type)
1910 {
1911         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_INTEGER;
1912 }
1913
1914 int bt_ctf_field_type_is_floating_point(struct bt_ctf_field_type *type)
1915 {
1916         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_FLOAT;
1917 }
1918
1919 int bt_ctf_field_type_is_enumeration(struct bt_ctf_field_type *type)
1920 {
1921         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_ENUM;
1922 }
1923
1924 int bt_ctf_field_type_is_string(struct bt_ctf_field_type *type)
1925 {
1926         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_STRING;
1927 }
1928
1929 int bt_ctf_field_type_is_structure(struct bt_ctf_field_type *type)
1930 {
1931         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_STRUCT;
1932 }
1933
1934 int bt_ctf_field_type_is_array(struct bt_ctf_field_type *type)
1935 {
1936         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_ARRAY;
1937 }
1938
1939 int bt_ctf_field_type_is_sequence(struct bt_ctf_field_type *type)
1940 {
1941         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_SEQUENCE;
1942 }
1943
1944 int bt_ctf_field_type_is_variant(struct bt_ctf_field_type *type)
1945 {
1946         return bt_ctf_field_type_get_type_id(type) == CTF_TYPE_VARIANT;
1947 }
1948
1949 void bt_ctf_field_type_get(struct bt_ctf_field_type *type)
1950 {
1951         bt_get(type);
1952 }
1953
1954 void bt_ctf_field_type_put(struct bt_ctf_field_type *type)
1955 {
1956         bt_put(type);
1957 }
1958
1959 BT_HIDDEN
1960 void bt_ctf_field_type_freeze(struct bt_ctf_field_type *type)
1961 {
1962         if (!type) {
1963                 return;
1964         }
1965
1966         type->freeze(type);
1967 }
1968
1969 BT_HIDDEN
1970 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_signed(
1971                 struct bt_ctf_field_type_variant *variant,
1972                 int64_t tag_value)
1973 {
1974         struct bt_ctf_field_type *type = NULL;
1975         GQuark field_name_quark;
1976         gpointer index;
1977         struct structure_field *field_entry;
1978         struct range_overlap_query query = {
1979                 .range_start._signed = tag_value,
1980                 .range_end._signed = tag_value,
1981                 .mapping_name = 0, .overlaps = 0};
1982
1983         g_ptr_array_foreach(variant->tag->entries, check_ranges_overlap,
1984                 &query);
1985         if (!query.overlaps) {
1986                 goto end;
1987         }
1988
1989         field_name_quark = query.mapping_name;
1990         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
1991                 GUINT_TO_POINTER(field_name_quark), NULL, &index)) {
1992                 goto end;
1993         }
1994
1995         field_entry = g_ptr_array_index(variant->fields, (size_t) index);
1996         type = field_entry->type;
1997 end:
1998         return type;
1999 }
2000
2001 BT_HIDDEN
2002 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_unsigned(
2003                 struct bt_ctf_field_type_variant *variant,
2004                 uint64_t tag_value)
2005 {
2006         struct bt_ctf_field_type *type = NULL;
2007         GQuark field_name_quark;
2008         gpointer index;
2009         struct structure_field *field_entry;
2010         struct range_overlap_query query = {
2011                 .range_start._unsigned = tag_value,
2012                 .range_end._unsigned = tag_value,
2013                 .mapping_name = 0, .overlaps = 0};
2014
2015         g_ptr_array_foreach(variant->tag->entries,
2016                 check_ranges_overlap_unsigned,
2017                 &query);
2018         if (!query.overlaps) {
2019                 goto end;
2020         }
2021
2022         field_name_quark = query.mapping_name;
2023         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
2024                 GUINT_TO_POINTER(field_name_quark), NULL, &index)) {
2025                 goto end;
2026         }
2027
2028         field_entry = g_ptr_array_index(variant->fields, (size_t)index);
2029         type = field_entry->type;
2030 end:
2031         return type;
2032 }
2033
2034 BT_HIDDEN
2035 int bt_ctf_field_type_serialize(struct bt_ctf_field_type *type,
2036                 struct metadata_context *context)
2037 {
2038         int ret;
2039
2040         if (!type || !context) {
2041                 ret = -1;
2042                 goto end;
2043         }
2044
2045         ret = type->serialize(type, context);
2046 end:
2047         return ret;
2048 }
2049
2050 BT_HIDDEN
2051 void bt_ctf_field_type_set_native_byte_order(struct bt_ctf_field_type *type,
2052                 int byte_order)
2053 {
2054         if (!type) {
2055                 return;
2056         }
2057
2058         assert(byte_order == LITTLE_ENDIAN || byte_order == BIG_ENDIAN);
2059         if (set_byte_order_funcs[type->declaration->id]) {
2060                 set_byte_order_funcs[type->declaration->id](type,
2061                         byte_order, 1);
2062         }
2063 }
2064
2065 BT_HIDDEN
2066 struct bt_ctf_field_type *bt_ctf_field_type_copy(struct bt_ctf_field_type *type)
2067 {
2068         struct bt_ctf_field_type *copy = NULL;
2069
2070         if (!type) {
2071                 goto end;
2072         }
2073
2074         copy = type_copy_funcs[type->declaration->id](type);
2075 end:
2076         return copy;
2077 }
2078
2079 BT_HIDDEN
2080 struct bt_ctf_field_path *bt_ctf_field_path_create(void)
2081 {
2082         struct bt_ctf_field_path *field_path = NULL;
2083
2084         field_path = g_new0(struct bt_ctf_field_path, 1);
2085         if (!field_path) {
2086                 goto end;
2087         }
2088
2089         field_path->root = CTF_NODE_UNKNOWN;
2090         field_path->path_indexes = g_array_new(TRUE, FALSE, sizeof(int));
2091         if (!field_path->path_indexes) {
2092                 bt_ctf_field_path_destroy(field_path);
2093                 field_path = NULL;
2094         }
2095 end:
2096         return field_path;
2097 }
2098
2099
2100 BT_HIDDEN
2101 struct bt_ctf_field_path *bt_ctf_field_path_copy(
2102                 struct bt_ctf_field_path *path)
2103 {
2104         struct bt_ctf_field_path *new_path = bt_ctf_field_path_create();
2105
2106         if (!new_path) {
2107                 goto end;
2108         }
2109
2110         new_path->root = path->root;
2111         g_array_insert_vals(new_path->path_indexes, 0,
2112                 path->path_indexes->data, path->path_indexes->len);
2113 end:
2114         return new_path;
2115 }
2116
2117 BT_HIDDEN
2118 void bt_ctf_field_path_destroy(struct bt_ctf_field_path *path)
2119 {
2120         if (!path) {
2121                 return;
2122         }
2123
2124         if (path->path_indexes) {
2125                 g_array_free(path->path_indexes, TRUE);
2126         }
2127         g_free(path);
2128 }
2129
2130 BT_HIDDEN
2131 int bt_ctf_field_type_structure_get_field_name_index(
2132                 struct bt_ctf_field_type *type, const char *name)
2133 {
2134         int ret;
2135         size_t index;
2136         GQuark name_quark;
2137         struct bt_ctf_field_type_structure *structure;
2138
2139         if (!type || !name ||
2140                 bt_ctf_field_type_get_type_id(type) != CTF_TYPE_STRUCT) {
2141                 ret = -1;
2142                 goto end;
2143         }
2144
2145         name_quark = g_quark_try_string(name);
2146         if (!name_quark) {
2147                 ret = -1;
2148                 goto end;
2149         }
2150
2151         structure = container_of(type, struct bt_ctf_field_type_structure,
2152                 parent);
2153         if (!g_hash_table_lookup_extended(structure->field_name_to_index,
2154                 GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
2155                 ret = -1;
2156                 goto end;
2157         }
2158         ret = (int) index;
2159 end:
2160         return ret;
2161 }
2162
2163 BT_HIDDEN
2164 int bt_ctf_field_type_structure_set_field_index(struct bt_ctf_field_type *type,
2165                 struct bt_ctf_field_type *field, int index)
2166 {
2167         int ret = 0;
2168         struct bt_ctf_field_type_structure *structure;
2169
2170         if (!type || !field ||
2171                 bt_ctf_field_type_get_type_id(type) != CTF_TYPE_STRUCT) {
2172                 ret = -1;
2173                 goto end;
2174         }
2175
2176         structure = container_of(type, struct bt_ctf_field_type_structure,
2177                 parent);
2178         if (index < 0 || index >= structure->fields->len) {
2179                 ret = -1;
2180                 goto end;
2181         }
2182
2183         bt_get(field);
2184         bt_put(((struct structure_field *)
2185                 g_ptr_array_index(structure->fields, index))->type);
2186         ((struct structure_field *) structure->fields->pdata[index])->type =
2187                 field;
2188 end:
2189         return ret;
2190 }
2191
2192 BT_HIDDEN
2193 int bt_ctf_field_type_variant_get_field_name_index(
2194                 struct bt_ctf_field_type *type, const char *name)
2195 {
2196         int ret;
2197         size_t index;
2198         GQuark name_quark;
2199         struct bt_ctf_field_type_variant *variant;
2200
2201         if (!type || !name ||
2202                 bt_ctf_field_type_get_type_id(type) != CTF_TYPE_VARIANT) {
2203                 ret = -1;
2204                 goto end;
2205         }
2206
2207         name_quark = g_quark_try_string(name);
2208         if (!name_quark) {
2209                 ret = -1;
2210                 goto end;
2211         }
2212
2213         variant = container_of(type, struct bt_ctf_field_type_variant,
2214                 parent);
2215         if (!g_hash_table_lookup_extended(variant->field_name_to_index,
2216                 GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
2217                 ret = -1;
2218                 goto end;
2219         }
2220         ret = (int) index;
2221 end:
2222         return ret;
2223 }
2224
2225 BT_HIDDEN
2226 int bt_ctf_field_type_sequence_set_length_field_path(
2227                 struct bt_ctf_field_type *type,
2228                 struct bt_ctf_field_path *path)
2229 {
2230         int ret = 0;
2231         struct bt_ctf_field_type_sequence *sequence;
2232
2233         if (!type || bt_ctf_field_type_get_type_id(type) != CTF_TYPE_SEQUENCE) {
2234                 ret = -1;
2235                 goto end;
2236         }
2237
2238         sequence = container_of(type, struct bt_ctf_field_type_sequence,
2239                 parent);
2240         if (sequence->length_field_path) {
2241                 bt_ctf_field_path_destroy(sequence->length_field_path);
2242         }
2243         sequence->length_field_path = path;
2244 end:
2245         return ret;
2246 }
2247
2248 BT_HIDDEN
2249 struct bt_ctf_field_path *bt_ctf_field_type_sequence_get_length_field_path(
2250                 struct bt_ctf_field_type *type)
2251 {
2252         struct bt_ctf_field_type_sequence *sequence;
2253
2254         sequence = container_of(type, struct bt_ctf_field_type_sequence,
2255                 parent);
2256
2257         return sequence->length_field_path;
2258 }
2259
2260 BT_HIDDEN
2261 int bt_ctf_field_type_variant_set_tag_field_path(struct bt_ctf_field_type *type,
2262                 struct bt_ctf_field_path *path)
2263 {
2264         int ret = 0;
2265         struct bt_ctf_field_type_variant *variant;
2266
2267         if (!type || bt_ctf_field_type_get_type_id(type) != CTF_TYPE_VARIANT) {
2268                 ret = -1;
2269                 goto end;
2270         }
2271
2272         variant = container_of(type, struct bt_ctf_field_type_variant,
2273                 parent);
2274         if (variant->tag_path) {
2275                 bt_ctf_field_path_destroy(variant->tag_path);
2276         }
2277         variant->tag_path = path;
2278 end:
2279         return ret;
2280 }
2281
2282 BT_HIDDEN
2283 struct bt_ctf_field_path *bt_ctf_field_type_variant_get_tag_field_path(
2284                 struct bt_ctf_field_type *type)
2285 {
2286         struct bt_ctf_field_type_variant *variant;
2287
2288         variant = container_of(type, struct bt_ctf_field_type_variant,
2289                 parent);
2290
2291         return variant->tag_path;
2292 }
2293
2294 BT_HIDDEN
2295 int bt_ctf_field_type_variant_set_tag(struct bt_ctf_field_type *type,
2296                 struct bt_ctf_field_type *tag)
2297 {
2298         int ret = 0;
2299         struct bt_ctf_field_type_variant *variant;
2300
2301         if (!type || !tag || type->frozen ||
2302                 bt_ctf_field_type_get_type_id(tag) != CTF_TYPE_ENUM) {
2303                 ret = -1;
2304                 goto end;
2305         }
2306
2307         variant = container_of(type, struct bt_ctf_field_type_variant,
2308                 parent);
2309         bt_get(tag);
2310         if (variant->tag) {
2311                 bt_put(&variant->tag->parent);
2312         }
2313         variant->tag = container_of(tag, struct bt_ctf_field_type_enumeration,
2314                 parent);
2315 end:
2316         return ret;
2317 }
2318
2319 BT_HIDDEN
2320 int bt_ctf_field_type_variant_set_field_index(struct bt_ctf_field_type *type,
2321                 struct bt_ctf_field_type *field, int index)
2322 {
2323         int ret = 0;
2324         struct bt_ctf_field_type_variant *variant;
2325
2326         if (!type || !field ||
2327                 bt_ctf_field_type_get_type_id(type) != CTF_TYPE_VARIANT) {
2328                 ret = -1;
2329                 goto end;
2330         }
2331
2332         variant = container_of(type, struct bt_ctf_field_type_variant,
2333                 parent);
2334         if (index < 0 || index >= variant->fields->len) {
2335                 ret = -1;
2336                 goto end;
2337         }
2338
2339         bt_get(field);
2340         bt_put(((struct structure_field *)
2341                 g_ptr_array_index(variant->fields, index))->type);
2342         ((struct structure_field *) variant->fields->pdata[index])->type =
2343                 field;
2344 end:
2345         return ret;
2346 }
2347
2348 static
2349 void bt_ctf_field_type_integer_destroy(struct bt_ctf_field_type *type)
2350 {
2351         struct bt_ctf_field_type_integer *integer =
2352                 (struct bt_ctf_field_type_integer *) type;
2353
2354         if (!type) {
2355                 return;
2356         }
2357
2358         bt_put(integer->mapped_clock);
2359         g_free(integer);
2360 }
2361
2362 static
2363 void bt_ctf_field_type_enumeration_destroy(struct bt_ctf_field_type *type)
2364 {
2365         struct bt_ctf_field_type_enumeration *enumeration =
2366                 (struct bt_ctf_field_type_enumeration *) type;
2367
2368         if (!type) {
2369                 return;
2370         }
2371
2372         g_ptr_array_free(enumeration->entries, TRUE);
2373         bt_put(enumeration->container);
2374         g_free(enumeration);
2375 }
2376
2377 static
2378 void bt_ctf_field_type_floating_point_destroy(struct bt_ctf_field_type *type)
2379 {
2380         struct bt_ctf_field_type_floating_point *floating_point =
2381                 (struct bt_ctf_field_type_floating_point *) type;
2382
2383         if (!type) {
2384                 return;
2385         }
2386
2387         g_free(floating_point);
2388 }
2389
2390 static
2391 void bt_ctf_field_type_structure_destroy(struct bt_ctf_field_type *type)
2392 {
2393         struct bt_ctf_field_type_structure *structure =
2394                 (struct bt_ctf_field_type_structure *) type;
2395
2396         if (!type) {
2397                 return;
2398         }
2399
2400         g_ptr_array_free(structure->fields, TRUE);
2401         g_hash_table_destroy(structure->field_name_to_index);
2402         g_free(structure);
2403 }
2404
2405 static
2406 void bt_ctf_field_type_variant_destroy(struct bt_ctf_field_type *type)
2407 {
2408         struct bt_ctf_field_type_variant *variant =
2409                 (struct bt_ctf_field_type_variant *) type;
2410
2411         if (!type) {
2412                 return;
2413         }
2414
2415         g_ptr_array_free(variant->fields, TRUE);
2416         g_hash_table_destroy(variant->field_name_to_index);
2417         g_string_free(variant->tag_name, TRUE);
2418         bt_put(&variant->tag->parent);
2419         bt_ctf_field_path_destroy(variant->tag_path);
2420         g_free(variant);
2421 }
2422
2423 static
2424 void bt_ctf_field_type_array_destroy(struct bt_ctf_field_type *type)
2425 {
2426         struct bt_ctf_field_type_array *array =
2427                 (struct bt_ctf_field_type_array *) type;
2428
2429         if (!type) {
2430                 return;
2431         }
2432
2433         bt_put(array->element_type);
2434         g_free(array);
2435 }
2436
2437 static
2438 void bt_ctf_field_type_sequence_destroy(struct bt_ctf_field_type *type)
2439 {
2440         struct bt_ctf_field_type_sequence *sequence =
2441                 (struct bt_ctf_field_type_sequence *) type;
2442
2443         if (!type) {
2444                 return;
2445         }
2446
2447         bt_put(sequence->element_type);
2448         g_string_free(sequence->length_field_name, TRUE);
2449         bt_ctf_field_path_destroy(sequence->length_field_path);
2450         g_free(sequence);
2451 }
2452
2453 static
2454 void bt_ctf_field_type_string_destroy(struct bt_ctf_field_type *type)
2455 {
2456         struct bt_ctf_field_type_string *string =
2457                 (struct bt_ctf_field_type_string *) type;
2458
2459         if (!type) {
2460                 return;
2461         }
2462
2463         g_free(string);
2464 }
2465
2466 static
2467 void generic_field_type_freeze(struct bt_ctf_field_type *type)
2468 {
2469         type->frozen = 1;
2470 }
2471
2472 static
2473 void bt_ctf_field_type_enumeration_freeze(struct bt_ctf_field_type *type)
2474 {
2475         struct bt_ctf_field_type_enumeration *enumeration_type = container_of(
2476                 type, struct bt_ctf_field_type_enumeration, parent);
2477
2478         generic_field_type_freeze(type);
2479         bt_ctf_field_type_freeze(enumeration_type->container);
2480 }
2481
2482 static
2483 void freeze_structure_field(struct structure_field *field)
2484 {
2485         bt_ctf_field_type_freeze(field->type);
2486 }
2487
2488 static
2489 void bt_ctf_field_type_structure_freeze(struct bt_ctf_field_type *type)
2490 {
2491         struct bt_ctf_field_type_structure *structure_type = container_of(
2492                 type, struct bt_ctf_field_type_structure, parent);
2493
2494         /* Cache the alignment */
2495         type->declaration->alignment = bt_ctf_field_type_get_alignment(type);
2496         generic_field_type_freeze(type);
2497         g_ptr_array_foreach(structure_type->fields,
2498                 (GFunc) freeze_structure_field, NULL);
2499 }
2500
2501 static
2502 void bt_ctf_field_type_variant_freeze(struct bt_ctf_field_type *type)
2503 {
2504         struct bt_ctf_field_type_variant *variant_type = container_of(
2505                 type, struct bt_ctf_field_type_variant, parent);
2506
2507         generic_field_type_freeze(type);
2508         g_ptr_array_foreach(variant_type->fields,
2509                 (GFunc) freeze_structure_field, NULL);
2510 }
2511
2512 static
2513 void bt_ctf_field_type_array_freeze(struct bt_ctf_field_type *type)
2514 {
2515         struct bt_ctf_field_type_array *array_type = container_of(
2516                 type, struct bt_ctf_field_type_array, parent);
2517
2518         /* Cache the alignment */
2519         type->declaration->alignment = bt_ctf_field_type_get_alignment(type);
2520         generic_field_type_freeze(type);
2521         bt_ctf_field_type_freeze(array_type->element_type);
2522 }
2523
2524 static
2525 void bt_ctf_field_type_sequence_freeze(struct bt_ctf_field_type *type)
2526 {
2527         struct bt_ctf_field_type_sequence *sequence_type = container_of(
2528                 type, struct bt_ctf_field_type_sequence, parent);
2529
2530         /* Cache the alignment */
2531         type->declaration->alignment = bt_ctf_field_type_get_alignment(type);
2532         generic_field_type_freeze(type);
2533         bt_ctf_field_type_freeze(sequence_type->element_type);
2534 }
2535
2536 static
2537 const char *get_encoding_string(enum ctf_string_encoding encoding)
2538 {
2539         const char *encoding_string;
2540
2541         switch (encoding) {
2542         case CTF_STRING_NONE:
2543                 encoding_string = "none";
2544                 break;
2545         case CTF_STRING_ASCII:
2546                 encoding_string = "ASCII";
2547                 break;
2548         case CTF_STRING_UTF8:
2549                 encoding_string = "UTF8";
2550                 break;
2551         default:
2552                 encoding_string = "unknown";
2553                 break;
2554         }
2555
2556         return encoding_string;
2557 }
2558
2559 static
2560 const char *get_integer_base_string(enum bt_ctf_integer_base base)
2561 {
2562         const char *base_string;
2563
2564         switch (base) {
2565         case BT_CTF_INTEGER_BASE_DECIMAL:
2566                 base_string = "decimal";
2567                 break;
2568         case BT_CTF_INTEGER_BASE_HEXADECIMAL:
2569                 base_string = "hexadecimal";
2570                 break;
2571         case BT_CTF_INTEGER_BASE_OCTAL:
2572                 base_string = "octal";
2573                 break;
2574         case BT_CTF_INTEGER_BASE_BINARY:
2575                 base_string = "binary";
2576                 break;
2577         default:
2578                 base_string = "unknown";
2579                 break;
2580         }
2581
2582         return base_string;
2583 }
2584
2585 static
2586 int bt_ctf_field_type_integer_serialize(struct bt_ctf_field_type *type,
2587                 struct metadata_context *context)
2588 {
2589         struct bt_ctf_field_type_integer *integer = container_of(type,
2590                 struct bt_ctf_field_type_integer, parent);
2591         int ret = 0;
2592
2593         g_string_append_printf(context->string,
2594                 "integer { size = %zu; align = %zu; signed = %s; encoding = %s; base = %s; byte_order = %s",
2595                 integer->declaration.len, type->declaration->alignment,
2596                 (integer->declaration.signedness ? "true" : "false"),
2597                 get_encoding_string(integer->declaration.encoding),
2598                 get_integer_base_string(integer->declaration.base),
2599                 get_byte_order_string(integer->declaration.byte_order));
2600         if (integer->mapped_clock) {
2601                 const char *clock_name = bt_ctf_clock_get_name(
2602                         integer->mapped_clock);
2603
2604                 if (!clock_name) {
2605                         ret = -1;
2606                         goto end;
2607                 }
2608
2609                 g_string_append_printf(context->string,
2610                         "; map = clock.%s.value", clock_name);
2611         }
2612
2613         g_string_append(context->string, "; }");
2614 end:
2615         return ret;
2616 }
2617
2618 static
2619 int bt_ctf_field_type_enumeration_serialize(struct bt_ctf_field_type *type,
2620                 struct metadata_context *context)
2621 {
2622         size_t entry;
2623         int ret;
2624         struct bt_ctf_field_type_enumeration *enumeration = container_of(type,
2625                 struct bt_ctf_field_type_enumeration, parent);
2626         struct bt_ctf_field_type *container_type;
2627         int container_signed;
2628
2629         ret = bt_ctf_field_type_validate(type);
2630         if (ret) {
2631                 goto end;
2632         }
2633
2634         container_type = bt_ctf_field_type_enumeration_get_container_type(type);
2635         if (!container_type) {
2636                 ret = -1;
2637                 goto end;
2638         }
2639
2640         container_signed = bt_ctf_field_type_integer_get_signed(container_type);
2641         if (container_signed < 0) {
2642                 ret = container_signed;
2643                 goto error_put_container_type;
2644         }
2645
2646         g_string_append(context->string, "enum : ");
2647         ret = bt_ctf_field_type_serialize(enumeration->container, context);
2648         if (ret) {
2649                 goto error_put_container_type;
2650         }
2651
2652         g_string_append(context->string, " { ");
2653         for (entry = 0; entry < enumeration->entries->len; entry++) {
2654                 struct enumeration_mapping *mapping =
2655                         enumeration->entries->pdata[entry];
2656
2657                 if (container_signed) {
2658                         if (mapping->range_start._signed ==
2659                                 mapping->range_end._signed) {
2660                                 g_string_append_printf(context->string,
2661                                         "\"%s\" = %" PRId64,
2662                                         g_quark_to_string(mapping->string),
2663                                         mapping->range_start._signed);
2664                         } else {
2665                                 g_string_append_printf(context->string,
2666                                         "\"%s\" = %" PRId64 " ... %" PRId64,
2667                                         g_quark_to_string(mapping->string),
2668                                         mapping->range_start._signed,
2669                                         mapping->range_end._signed);
2670                         }
2671                 } else {
2672                         if (mapping->range_start._unsigned ==
2673                                 mapping->range_end._unsigned) {
2674                                 g_string_append_printf(context->string,
2675                                         "\"%s\" = %" PRIu64,
2676                                         g_quark_to_string(mapping->string),
2677                                         mapping->range_start._unsigned);
2678                         } else {
2679                                 g_string_append_printf(context->string,
2680                                         "\"%s\" = %" PRIu64 " ... %" PRIu64,
2681                                         g_quark_to_string(mapping->string),
2682                                         mapping->range_start._unsigned,
2683                                         mapping->range_end._unsigned);
2684                         }
2685                 }
2686
2687                 g_string_append(context->string,
2688                         ((entry != (enumeration->entries->len - 1)) ?
2689                         ", " : " }"));
2690         }
2691
2692         if (context->field_name->len) {
2693                 g_string_append_printf(context->string, " %s",
2694                         context->field_name->str);
2695                 g_string_assign(context->field_name, "");
2696         }
2697 error_put_container_type:
2698         bt_put(container_type);
2699 end:
2700         return ret;
2701 }
2702
2703 static
2704 int bt_ctf_field_type_floating_point_serialize(struct bt_ctf_field_type *type,
2705                 struct metadata_context *context)
2706 {
2707         struct bt_ctf_field_type_floating_point *floating_point = container_of(
2708                 type, struct bt_ctf_field_type_floating_point, parent);
2709
2710         g_string_append_printf(context->string,
2711                 "floating_point { exp_dig = %zu; mant_dig = %zu; byte_order = %s; align = %zu; }",
2712                 floating_point->declaration.exp->len,
2713                 floating_point->declaration.mantissa->len + 1,
2714                 get_byte_order_string(floating_point->declaration.byte_order),
2715                 type->declaration->alignment);
2716         return 0;
2717 }
2718
2719 static
2720 int bt_ctf_field_type_structure_serialize(struct bt_ctf_field_type *type,
2721                 struct metadata_context *context)
2722 {
2723         size_t i;
2724         unsigned int indent;
2725         int ret = 0;
2726         struct bt_ctf_field_type_structure *structure = container_of(type,
2727                 struct bt_ctf_field_type_structure, parent);
2728         GString *structure_field_name = context->field_name;
2729
2730         context->field_name = g_string_new("");
2731
2732         context->current_indentation_level++;
2733         g_string_append(context->string, "struct {\n");
2734
2735         for (i = 0; i < structure->fields->len; i++) {
2736                 struct structure_field *field;
2737
2738                 for (indent = 0; indent < context->current_indentation_level;
2739                         indent++) {
2740                         g_string_append_c(context->string, '\t');
2741                 }
2742
2743                 field = structure->fields->pdata[i];
2744                 g_string_assign(context->field_name,
2745                         g_quark_to_string(field->name));
2746                 ret = bt_ctf_field_type_serialize(field->type, context);
2747                 if (ret) {
2748                         goto end;
2749                 }
2750
2751                 if (context->field_name->len) {
2752                         g_string_append_printf(context->string, " %s",
2753                                 context->field_name->str);
2754                 }
2755                 g_string_append(context->string, ";\n");
2756         }
2757
2758         context->current_indentation_level--;
2759         for (indent = 0; indent < context->current_indentation_level;
2760                 indent++) {
2761                 g_string_append_c(context->string, '\t');
2762         }
2763
2764         g_string_append_printf(context->string, "} align(%zu)",
2765                  type->declaration->alignment);
2766 end:
2767         g_string_free(context->field_name, TRUE);
2768         context->field_name = structure_field_name;
2769         return ret;
2770 }
2771
2772 static
2773 int bt_ctf_field_type_variant_serialize(struct bt_ctf_field_type *type,
2774                 struct metadata_context *context)
2775 {
2776         size_t i;
2777         unsigned int indent;
2778         int ret = 0;
2779         struct bt_ctf_field_type_variant *variant = container_of(
2780                 type, struct bt_ctf_field_type_variant, parent);
2781         GString *variant_field_name = context->field_name;
2782
2783         context->field_name = g_string_new("");
2784         if (variant->tag_name->len > 0) {
2785                 g_string_append_printf(context->string,
2786                         "variant <%s> {\n", variant->tag_name->str);
2787         } else {
2788                 g_string_append(context->string, "variant {\n");
2789         }
2790
2791         context->current_indentation_level++;
2792         for (i = 0; i < variant->fields->len; i++) {
2793                 struct structure_field *field = variant->fields->pdata[i];
2794
2795                 g_string_assign(context->field_name,
2796                         g_quark_to_string(field->name));
2797                 for (indent = 0; indent < context->current_indentation_level;
2798                         indent++) {
2799                         g_string_append_c(context->string, '\t');
2800                 }
2801
2802                 g_string_assign(context->field_name,
2803                         g_quark_to_string(field->name));
2804                 ret = bt_ctf_field_type_serialize(field->type, context);
2805                 if (ret) {
2806                         goto end;
2807                 }
2808
2809                 if (context->field_name->len) {
2810                         g_string_append_printf(context->string, " %s;",
2811                                 context->field_name->str);
2812                 }
2813
2814                 g_string_append_c(context->string, '\n');
2815         }
2816
2817         context->current_indentation_level--;
2818         for (indent = 0; indent < context->current_indentation_level;
2819                 indent++) {
2820                 g_string_append_c(context->string, '\t');
2821         }
2822
2823         g_string_append(context->string, "}");
2824 end:
2825         g_string_free(context->field_name, TRUE);
2826         context->field_name = variant_field_name;
2827         return ret;
2828 }
2829
2830 static
2831 int bt_ctf_field_type_array_serialize(struct bt_ctf_field_type *type,
2832                 struct metadata_context *context)
2833 {
2834         int ret = 0;
2835         struct bt_ctf_field_type_array *array = container_of(type,
2836                 struct bt_ctf_field_type_array, parent);
2837
2838         ret = bt_ctf_field_type_serialize(array->element_type, context);
2839         if (ret) {
2840                 goto end;
2841         }
2842
2843         if (context->field_name->len) {
2844                 g_string_append_printf(context->string, " %s[%u]",
2845                         context->field_name->str, array->length);
2846                 g_string_assign(context->field_name, "");
2847         } else {
2848                 g_string_append_printf(context->string, "[%u]", array->length);
2849         }
2850 end:
2851         return ret;
2852 }
2853
2854 static
2855 int bt_ctf_field_type_sequence_serialize(struct bt_ctf_field_type *type,
2856                 struct metadata_context *context)
2857 {
2858         int ret = 0;
2859         struct bt_ctf_field_type_sequence *sequence = container_of(
2860                 type, struct bt_ctf_field_type_sequence, parent);
2861
2862         ret = bt_ctf_field_type_serialize(sequence->element_type, context);
2863         if (ret) {
2864                 goto end;
2865         }
2866
2867         if (context->field_name->len) {
2868                 g_string_append_printf(context->string, " %s[%s]",
2869                         context->field_name->str,
2870                         sequence->length_field_name->str);
2871                 g_string_assign(context->field_name, "");
2872         } else {
2873                 g_string_append_printf(context->string, "[%s]",
2874                         sequence->length_field_name->str);
2875         }
2876 end:
2877         return ret;
2878 }
2879
2880 static
2881 int bt_ctf_field_type_string_serialize(struct bt_ctf_field_type *type,
2882                 struct metadata_context *context)
2883 {
2884         struct bt_ctf_field_type_string *string = container_of(
2885                 type, struct bt_ctf_field_type_string, parent);
2886
2887         g_string_append_printf(context->string,
2888                 "string { encoding = %s; }",
2889                 get_encoding_string(string->declaration.encoding));
2890         return 0;
2891 }
2892
2893 static
2894 void bt_ctf_field_type_integer_set_byte_order(struct bt_ctf_field_type *type,
2895                 int byte_order, int set_native)
2896 {
2897         struct bt_ctf_field_type_integer *integer_type = container_of(type,
2898                 struct bt_ctf_field_type_integer, parent);
2899
2900         if (set_native) {
2901                 integer_type->declaration.byte_order =
2902                         integer_type->declaration.byte_order == 0 ?
2903                         byte_order : integer_type->declaration.byte_order;
2904         } else {
2905                 integer_type->declaration.byte_order = byte_order;
2906         }
2907 }
2908
2909 static
2910 void bt_ctf_field_type_enumeration_set_byte_order(
2911                 struct bt_ctf_field_type *type, int byte_order, int set_native)
2912 {
2913         struct bt_ctf_field_type_enumeration *enum_type = container_of(type,
2914                 struct bt_ctf_field_type_enumeration, parent);
2915
2916         /* Safe to assume that container is an integer */
2917         bt_ctf_field_type_integer_set_byte_order(enum_type->container,
2918                 byte_order, set_native);
2919 }
2920
2921 static
2922 void bt_ctf_field_type_floating_point_set_byte_order(
2923                 struct bt_ctf_field_type *type, int byte_order, int set_native)
2924 {
2925         struct bt_ctf_field_type_floating_point *floating_point_type =
2926                 container_of(type, struct bt_ctf_field_type_floating_point,
2927                 parent);
2928
2929         if (set_native) {
2930                 floating_point_type->declaration.byte_order =
2931                         floating_point_type->declaration.byte_order == 0 ?
2932                         byte_order :
2933                         floating_point_type->declaration.byte_order;
2934                 floating_point_type->sign.byte_order =
2935                         floating_point_type->sign.byte_order == 0 ?
2936                         byte_order : floating_point_type->sign.byte_order;
2937                 floating_point_type->mantissa.byte_order =
2938                         floating_point_type->mantissa.byte_order == 0 ?
2939                         byte_order : floating_point_type->mantissa.byte_order;
2940                 floating_point_type->exp.byte_order =
2941                         floating_point_type->exp.byte_order == 0 ?
2942                         byte_order : floating_point_type->exp.byte_order;
2943         } else {
2944                 floating_point_type->declaration.byte_order = byte_order;
2945                 floating_point_type->sign.byte_order = byte_order;
2946                 floating_point_type->mantissa.byte_order = byte_order;
2947                 floating_point_type->exp.byte_order = byte_order;
2948         }
2949 }
2950
2951 static
2952 void bt_ctf_field_type_structure_set_byte_order(struct bt_ctf_field_type *type,
2953                 int byte_order, int set_native)
2954 {
2955         int i;
2956         struct bt_ctf_field_type_structure *structure_type =
2957                 container_of(type, struct bt_ctf_field_type_structure,
2958                 parent);
2959
2960         for (i = 0; i < structure_type->fields->len; i++) {
2961                 struct structure_field *field = g_ptr_array_index(
2962                         structure_type->fields, i);
2963                 struct bt_ctf_field_type *field_type = field->type;
2964
2965                 if (set_byte_order_funcs[field_type->declaration->id]) {
2966                         set_byte_order_funcs[field_type->declaration->id](
2967                                 field_type, byte_order, set_native);
2968                 }
2969         }
2970 }
2971
2972 static
2973 void bt_ctf_field_type_variant_set_byte_order(struct bt_ctf_field_type *type,
2974                 int byte_order, int set_native)
2975 {
2976         int i;
2977         struct bt_ctf_field_type_variant *variant_type =
2978                 container_of(type, struct bt_ctf_field_type_variant,
2979                 parent);
2980
2981         for (i = 0; i < variant_type->fields->len; i++) {
2982                 struct structure_field *field = g_ptr_array_index(
2983                         variant_type->fields, i);
2984                 struct bt_ctf_field_type *field_type = field->type;
2985
2986                 if (set_byte_order_funcs[field_type->declaration->id]) {
2987                         set_byte_order_funcs[field_type->declaration->id](
2988                                 field_type, byte_order, set_native);
2989                 }
2990         }
2991 }
2992
2993 static
2994 void bt_ctf_field_type_array_set_byte_order(struct bt_ctf_field_type *type,
2995                 int byte_order, int set_native)
2996 {
2997         struct bt_ctf_field_type_array *array_type =
2998                 container_of(type, struct bt_ctf_field_type_array,
2999                 parent);
3000
3001         if (set_byte_order_funcs[array_type->element_type->declaration->id]) {
3002                 set_byte_order_funcs[array_type->element_type->declaration->id](
3003                         array_type->element_type, byte_order, set_native);
3004         }
3005 }
3006
3007 static
3008 void bt_ctf_field_type_sequence_set_byte_order(struct bt_ctf_field_type *type,
3009                 int byte_order, int set_native)
3010 {
3011         struct bt_ctf_field_type_sequence *sequence_type =
3012                 container_of(type, struct bt_ctf_field_type_sequence,
3013                 parent);
3014
3015         if (set_byte_order_funcs[
3016                 sequence_type->element_type->declaration->id]) {
3017                 set_byte_order_funcs[
3018                         sequence_type->element_type->declaration->id](
3019                         sequence_type->element_type, byte_order, set_native);
3020         }
3021 }
3022
3023 static
3024 struct bt_ctf_field_type *bt_ctf_field_type_integer_copy(
3025                 struct bt_ctf_field_type *type)
3026 {
3027         struct bt_ctf_field_type *copy;
3028         struct bt_ctf_field_type_integer *integer, *copy_integer;
3029
3030         integer = container_of(type, struct bt_ctf_field_type_integer, parent);
3031         copy = bt_ctf_field_type_integer_create(integer->declaration.len);
3032         if (!copy) {
3033                 goto end;
3034         }
3035
3036         copy_integer = container_of(copy, struct bt_ctf_field_type_integer,
3037                 parent);
3038         copy_integer->declaration = integer->declaration;
3039         if (integer->mapped_clock) {
3040                 bt_get(integer->mapped_clock);
3041                 copy_integer->mapped_clock = integer->mapped_clock;
3042         }
3043 end:
3044         return copy;
3045 }
3046
3047 static
3048 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_copy(
3049                 struct bt_ctf_field_type *type)
3050 {
3051         size_t i;
3052         struct bt_ctf_field_type *copy = NULL, *copy_container;
3053         struct bt_ctf_field_type_enumeration *enumeration, *copy_enumeration;
3054
3055         enumeration = container_of(type, struct bt_ctf_field_type_enumeration,
3056                 parent);
3057
3058         /* Copy the source enumeration's container */
3059         copy_container = bt_ctf_field_type_copy(enumeration->container);
3060         if (!copy_container) {
3061                 goto end;
3062         }
3063
3064         copy = bt_ctf_field_type_enumeration_create(copy_container);
3065         if (!copy) {
3066                 goto end;
3067         }
3068         copy_enumeration = container_of(copy,
3069                 struct bt_ctf_field_type_enumeration, parent);
3070
3071         /* Copy all enumaration entries */
3072         for (i = 0; i < enumeration->entries->len; i++) {
3073                 struct enumeration_mapping *mapping = g_ptr_array_index(
3074                         enumeration->entries, i);
3075                 struct enumeration_mapping* copy_mapping = g_new0(
3076                         struct enumeration_mapping, 1);
3077
3078                 if (!copy_mapping) {
3079                         goto error;
3080                 }
3081
3082                 *copy_mapping = *mapping;
3083                 g_ptr_array_add(copy_enumeration->entries, copy_mapping);
3084         }
3085
3086         copy_enumeration->declaration = enumeration->declaration;
3087 end:
3088         bt_put(copy_container);
3089         return copy;
3090 error:
3091         bt_put(copy_container);
3092         BT_PUT(copy);
3093         return copy;
3094 }
3095
3096 static
3097 struct bt_ctf_field_type *bt_ctf_field_type_floating_point_copy(
3098                 struct bt_ctf_field_type *type)
3099 {
3100         struct bt_ctf_field_type *copy;
3101         struct bt_ctf_field_type_floating_point *floating_point, *copy_float;
3102
3103         floating_point = container_of(type,
3104                 struct bt_ctf_field_type_floating_point, parent);
3105         copy = bt_ctf_field_type_floating_point_create();
3106         if (!copy) {
3107                 goto end;
3108         }
3109
3110         copy_float = container_of(copy,
3111                 struct bt_ctf_field_type_floating_point, parent);
3112         copy_float->declaration = floating_point->declaration;
3113         copy_float->sign = floating_point->sign;
3114         copy_float->mantissa = floating_point->mantissa;
3115         copy_float->exp = floating_point->exp;
3116 end:
3117         return copy;
3118 }
3119
3120 static
3121 struct bt_ctf_field_type *bt_ctf_field_type_structure_copy(
3122                 struct bt_ctf_field_type *type)
3123 {
3124         int i;
3125         GHashTableIter iter;
3126         gpointer key, value;
3127         struct bt_ctf_field_type *copy;
3128         struct bt_ctf_field_type_structure *structure, *copy_structure;
3129
3130         structure = container_of(type, struct bt_ctf_field_type_structure,
3131                 parent);
3132         copy = bt_ctf_field_type_structure_create();
3133         if (!copy) {
3134                 goto end;
3135         }
3136
3137         copy_structure = container_of(copy,
3138                 struct bt_ctf_field_type_structure, parent);
3139
3140         /* Copy field_name_to_index */
3141         g_hash_table_iter_init(&iter, structure->field_name_to_index);
3142         while (g_hash_table_iter_next (&iter, &key, &value)) {
3143                 g_hash_table_insert(copy_structure->field_name_to_index,
3144                         key, value);
3145         }
3146
3147         for (i = 0; i < structure->fields->len; i++) {
3148                 struct structure_field *entry, *copy_entry;
3149                 struct bt_ctf_field_type *copy_field;
3150
3151                 copy_entry = g_new0(struct structure_field, 1);
3152                 if (!copy_entry) {
3153                         goto error;
3154                 }
3155
3156                 entry = g_ptr_array_index(structure->fields, i);
3157                 copy_field = bt_ctf_field_type_copy(entry->type);
3158                 if (!copy_field) {
3159                         g_free(copy_entry);
3160                         goto error;
3161                 }
3162
3163                 copy_entry->name = entry->name;
3164                 copy_entry->type = copy_field;
3165                 g_ptr_array_add(copy_structure->fields, copy_entry);
3166         }
3167
3168         copy_structure->declaration = structure->declaration;
3169 end:
3170         return copy;
3171 error:
3172         BT_PUT(copy);
3173         return copy;
3174 }
3175
3176 static
3177 struct bt_ctf_field_type *bt_ctf_field_type_variant_copy(
3178                 struct bt_ctf_field_type *type)
3179 {
3180         int i;
3181         GHashTableIter iter;
3182         gpointer key, value;
3183         struct bt_ctf_field_type *copy = NULL, *copy_tag = NULL;
3184         struct bt_ctf_field_type_variant *variant, *copy_variant;
3185
3186         variant = container_of(type, struct bt_ctf_field_type_variant,
3187                 parent);
3188         if (variant->tag) {
3189                 copy_tag = bt_ctf_field_type_copy(&variant->tag->parent);
3190                 if (!copy_tag) {
3191                         goto end;
3192                 }
3193         }
3194
3195         copy = bt_ctf_field_type_variant_create(copy_tag,
3196                 variant->tag_name->len ? variant->tag_name->str : NULL);
3197         if (!copy) {
3198                 goto end;
3199         }
3200
3201         copy_variant = container_of(copy, struct bt_ctf_field_type_variant,
3202                 parent);
3203
3204         /* Copy field_name_to_index */
3205         g_hash_table_iter_init(&iter, variant->field_name_to_index);
3206         while (g_hash_table_iter_next (&iter, &key, &value)) {
3207                 g_hash_table_insert(copy_variant->field_name_to_index,
3208                         key, value);
3209         }
3210
3211         for (i = 0; i < variant->fields->len; i++) {
3212                 struct structure_field *entry, *copy_entry;
3213                 struct bt_ctf_field_type *copy_field;
3214
3215                 copy_entry = g_new0(struct structure_field, 1);
3216                 if (!copy_entry) {
3217                         goto error;
3218                 }
3219
3220                 entry = g_ptr_array_index(variant->fields, i);
3221                 copy_field = bt_ctf_field_type_copy(entry->type);
3222                 if (!copy_field) {
3223                         g_free(copy_entry);
3224                         goto error;
3225                 }
3226
3227                 copy_entry->name = entry->name;
3228                 copy_entry->type = copy_field;
3229                 g_ptr_array_add(copy_variant->fields, copy_entry);
3230         }
3231
3232         copy_variant->declaration = variant->declaration;
3233         if (variant->tag_path) {
3234                 copy_variant->tag_path = bt_ctf_field_path_copy(
3235                         variant->tag_path);
3236                 if (!copy_variant->tag_path) {
3237                         goto error;
3238                 }
3239         }
3240 end:
3241         bt_put(copy_tag);
3242         return copy;
3243 error:
3244         bt_put(copy_tag);
3245         BT_PUT(copy);
3246         return copy;
3247 }
3248
3249 static
3250 struct bt_ctf_field_type *bt_ctf_field_type_array_copy(
3251                 struct bt_ctf_field_type *type)
3252 {
3253         struct bt_ctf_field_type *copy = NULL, *copy_element;
3254         struct bt_ctf_field_type_array *array, *copy_array;
3255
3256         array = container_of(type, struct bt_ctf_field_type_array,
3257                 parent);
3258         copy_element = bt_ctf_field_type_copy(array->element_type);
3259         if (!copy_element) {
3260                 goto end;
3261         }
3262
3263         copy = bt_ctf_field_type_array_create(copy_element, array->length);
3264         if (!copy) {
3265                 goto end;
3266         }
3267
3268         copy_array = container_of(copy, struct bt_ctf_field_type_array,
3269                 parent);
3270         copy_array->declaration = array->declaration;
3271 end:
3272         bt_put(copy_element);
3273         return copy;
3274 }
3275
3276 static
3277 struct bt_ctf_field_type *bt_ctf_field_type_sequence_copy(
3278                 struct bt_ctf_field_type *type)
3279 {
3280         struct bt_ctf_field_type *copy = NULL, *copy_element;
3281         struct bt_ctf_field_type_sequence *sequence, *copy_sequence;
3282
3283         sequence = container_of(type, struct bt_ctf_field_type_sequence,
3284                 parent);
3285         copy_element = bt_ctf_field_type_copy(sequence->element_type);
3286         if (!copy_element) {
3287                 goto end;
3288         }
3289
3290         copy = bt_ctf_field_type_sequence_create(copy_element,
3291                 sequence->length_field_name->len ?
3292                         sequence->length_field_name->str : NULL);
3293         if (!copy) {
3294                 goto end;
3295         }
3296
3297         copy_sequence = container_of(copy, struct bt_ctf_field_type_sequence,
3298                 parent);
3299         copy_sequence->declaration = sequence->declaration;
3300         if (sequence->length_field_path) {
3301                 copy_sequence->length_field_path = bt_ctf_field_path_copy(
3302                         sequence->length_field_path);
3303                 if (!copy_sequence->length_field_path) {
3304                         goto error;
3305                 }
3306         }
3307 end:
3308         bt_put(copy_element);
3309         return copy;
3310 error:
3311         BT_PUT(copy);
3312         goto end;
3313 }
3314
3315 static
3316 struct bt_ctf_field_type *bt_ctf_field_type_string_copy(
3317                 struct bt_ctf_field_type *type)
3318 {
3319         struct bt_ctf_field_type *copy;
3320         struct bt_ctf_field_type_string *string, *copy_string;
3321
3322         copy = bt_ctf_field_type_string_create();
3323         if (!copy) {
3324                 goto end;
3325         }
3326
3327         string = container_of(type, struct bt_ctf_field_type_string,
3328                 parent);
3329         copy_string = container_of(type, struct bt_ctf_field_type_string,
3330                 parent);
3331         copy_string->declaration = string->declaration;
3332 end:
3333         return copy;
3334 }