projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: uninitialized variable may be used warning
[babeltrace.git] / lib / ctf-ir / field-types.c
CommitLineData
273b65be 1/*
2e33ac5a 2 * field-types.c
273b65be 3 *
d2dc44b6 4 * Babeltrace CTF IR - Event Types
273b65be 5 *
de9dd397 6 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
273b65be
JG		 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
4e8304f7
PP		 29#define BT_LOG_TAG "FIELD-TYPES"
30#include <babeltrace/lib-logging-internal.h>
31
2e33ac5a 32#include <babeltrace/ctf-ir/field-types-internal.h>
b011f6b0 33#include <babeltrace/ctf-ir/field-path-internal.h>
654c1444 34#include <babeltrace/ctf-ir/utils.h>
83509119 35#include <babeltrace/ref.h>
ac0c6bdd
PP		 36#include <babeltrace/ctf-ir/clock-class.h>
37#include <babeltrace/ctf-ir/clock-class-internal.h>
273b65be 38#include <babeltrace/ctf-writer/writer-internal.h>
83509119
JG		 39#include <babeltrace/object-internal.h>
40#include <babeltrace/ref.h>
3d9990ac
PP		 41#include <babeltrace/compiler-internal.h>
42#include <babeltrace/endian-internal.h>
273b65be
JG		 43#include <float.h>
44#include <inttypes.h>
a39fa057 45#include <stdlib.h>
273b65be
JG		 46
47struct range_overlap_query {
b92ddaaa
JG		 48 union {
49 uint64_t _unsigned;
50 int64_t _signed;
51 } range_start;
52
53 union {
54 uint64_t _unsigned;
55 int64_t _signed;
56 } range_end;
273b65be
JG		 57 int overlaps;
58 GQuark mapping_name;
59};
60
2f2d8e05 61static
50842bdc 62void bt_field_type_destroy(struct bt_object *);
273b65be 63static
50842bdc 64void bt_field_type_integer_destroy(struct bt_field_type *);
273b65be 65static
50842bdc 66void bt_field_type_enumeration_destroy(struct bt_field_type *);
273b65be 67static
50842bdc 68void bt_field_type_floating_point_destroy(struct bt_field_type *);
273b65be 69static
50842bdc 70void bt_field_type_structure_destroy(struct bt_field_type *);
273b65be 71static
50842bdc 72void bt_field_type_variant_destroy(struct bt_field_type *);
273b65be 73static
50842bdc 74void bt_field_type_array_destroy(struct bt_field_type *);
273b65be 75static
50842bdc 76void bt_field_type_sequence_destroy(struct bt_field_type *);
273b65be 77static
50842bdc 78void bt_field_type_string_destroy(struct bt_field_type *);
273b65be
JG		 79
80static
50842bdc
PP		 81void (* const type_destroy_funcs[])(struct bt_field_type *) = {
82 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_destroy,
83 [BT_FIELD_TYPE_ID_ENUM] =
84 bt_field_type_enumeration_destroy,
85 [BT_FIELD_TYPE_ID_FLOAT] =
86 bt_field_type_floating_point_destroy,
87 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_destroy,
88 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_destroy,
89 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_destroy,
90 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_destroy,
91 [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_destroy,
273b65be
JG		 92};
93
94static
50842bdc 95void generic_field_type_freeze(struct bt_field_type *);
273b65be 96static
50842bdc 97void bt_field_type_integer_freeze(struct bt_field_type *);
586411e5 98static
50842bdc 99void bt_field_type_enumeration_freeze(struct bt_field_type *);
273b65be 100static
50842bdc 101void bt_field_type_structure_freeze(struct bt_field_type *);
273b65be 102static
50842bdc 103void bt_field_type_variant_freeze(struct bt_field_type *);
273b65be 104static
50842bdc 105void bt_field_type_array_freeze(struct bt_field_type *);
273b65be 106static
50842bdc 107void bt_field_type_sequence_freeze(struct bt_field_type *);
273b65be
JG		 108
109static
110type_freeze_func const type_freeze_funcs[] = {
50842bdc
PP		 111 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_freeze,
112 [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_freeze,
113 [BT_FIELD_TYPE_ID_FLOAT] = generic_field_type_freeze,
114 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_freeze,
115 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_freeze,
116 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_freeze,
117 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_freeze,
118 [BT_FIELD_TYPE_ID_STRING] = generic_field_type_freeze,
273b65be
JG		 119};
120
121static
50842bdc 122int bt_field_type_integer_serialize(struct bt_field_type *,
273b65be
JG		 123 struct metadata_context *);
124static
50842bdc 125int bt_field_type_enumeration_serialize(struct bt_field_type *,
273b65be
JG		 126 struct metadata_context *);
127static
50842bdc
PP		 128int bt_field_type_floating_point_serialize(
129 struct bt_field_type *, struct metadata_context *);
273b65be 130static
50842bdc 131int bt_field_type_structure_serialize(struct bt_field_type *,
273b65be
JG		 132 struct metadata_context *);
133static
50842bdc 134int bt_field_type_variant_serialize(struct bt_field_type *,
273b65be
JG		 135 struct metadata_context *);
136static
50842bdc 137int bt_field_type_array_serialize(struct bt_field_type *,
273b65be
JG		 138 struct metadata_context *);
139static
50842bdc 140int bt_field_type_sequence_serialize(struct bt_field_type *,
273b65be
JG		 141 struct metadata_context *);
142static
50842bdc 143int bt_field_type_string_serialize(struct bt_field_type *,
273b65be
JG		 144 struct metadata_context *);
145
146static
147type_serialize_func const type_serialize_funcs[] = {
50842bdc
PP		 148 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_serialize,
149 [BT_FIELD_TYPE_ID_ENUM] =
150 bt_field_type_enumeration_serialize,
151 [BT_FIELD_TYPE_ID_FLOAT] =
152 bt_field_type_floating_point_serialize,
153 [BT_FIELD_TYPE_ID_STRUCT] =
154 bt_field_type_structure_serialize,
155 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_serialize,
156 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_serialize,
157 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_serialize,
158 [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_serialize,
273b65be
JG		 159};
160
161static
50842bdc
PP		 162void bt_field_type_integer_set_byte_order(struct bt_field_type *,
163 enum bt_byte_order byte_order);
c35a1669 164static
50842bdc
PP		 165void bt_field_type_enumeration_set_byte_order(struct bt_field_type *,
166 enum bt_byte_order byte_order);
273b65be 167static
50842bdc
PP		 168void bt_field_type_floating_point_set_byte_order(
169 struct bt_field_type *, enum bt_byte_order byte_order);
c35a1669 170static
50842bdc
PP		 171void bt_field_type_structure_set_byte_order(struct bt_field_type *,
172 enum bt_byte_order byte_order);
c35a1669 173static
50842bdc
PP		 174void bt_field_type_variant_set_byte_order(struct bt_field_type *,
175 enum bt_byte_order byte_order);
c35a1669 176static
50842bdc
PP		 177void bt_field_type_array_set_byte_order(struct bt_field_type *,
178 enum bt_byte_order byte_order);
c35a1669 179static
50842bdc
PP		 180void bt_field_type_sequence_set_byte_order(struct bt_field_type *,
181 enum bt_byte_order byte_order);
273b65be
JG		 182
183static
50842bdc
PP		 184void (* const set_byte_order_funcs[])(struct bt_field_type *,
185 enum bt_byte_order) = {
186 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_set_byte_order,
187 [BT_FIELD_TYPE_ID_ENUM] =
188 bt_field_type_enumeration_set_byte_order,
189 [BT_FIELD_TYPE_ID_FLOAT] =
190 bt_field_type_floating_point_set_byte_order,
191 [BT_FIELD_TYPE_ID_STRUCT] =
192 bt_field_type_structure_set_byte_order,
193 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_set_byte_order,
194 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_set_byte_order,
195 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_set_byte_order,
196 [BT_FIELD_TYPE_ID_STRING] = NULL,
273b65be
JG		 197};
198
24724933 199static
50842bdc
PP		 200struct bt_field_type *bt_field_type_integer_copy(
201 struct bt_field_type *);
24724933 202static
50842bdc
PP		 203struct bt_field_type *bt_field_type_enumeration_copy(
204 struct bt_field_type *);
24724933 205static
50842bdc
PP		 206struct bt_field_type *bt_field_type_floating_point_copy(
207 struct bt_field_type *);
24724933 208static
50842bdc
PP		 209struct bt_field_type *bt_field_type_structure_copy(
210 struct bt_field_type *);
24724933 211static
50842bdc
PP		 212struct bt_field_type *bt_field_type_variant_copy(
213 struct bt_field_type *);
24724933 214static
50842bdc
PP		 215struct bt_field_type *bt_field_type_array_copy(
216 struct bt_field_type *);
24724933 217static
50842bdc
PP		 218struct bt_field_type *bt_field_type_sequence_copy(
219 struct bt_field_type *);
24724933 220static
50842bdc
PP		 221struct bt_field_type *bt_field_type_string_copy(
222 struct bt_field_type *);
24724933
JG		 223
224static
50842bdc
PP		 225struct bt_field_type *(* const type_copy_funcs[])(
226 struct bt_field_type *) = {
227 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_copy,
228 [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_copy,
229 [BT_FIELD_TYPE_ID_FLOAT] = bt_field_type_floating_point_copy,
230 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_copy,
231 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_copy,
232 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_copy,
233 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_copy,
234 [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_copy,
24724933
JG		 235};
236
265e809c 237static
50842bdc
PP		 238int bt_field_type_integer_compare(struct bt_field_type *,
239 struct bt_field_type *);
265e809c 240static
50842bdc
PP		 241int bt_field_type_floating_point_compare(struct bt_field_type *,
242 struct bt_field_type *);
265e809c 243static
50842bdc
PP		 244int bt_field_type_enumeration_compare(struct bt_field_type *,
245 struct bt_field_type *);
265e809c 246static
50842bdc
PP		 247int bt_field_type_string_compare(struct bt_field_type *,
248 struct bt_field_type *);
265e809c 249static
50842bdc
PP		 250int bt_field_type_structure_compare(struct bt_field_type *,
251 struct bt_field_type *);
265e809c 252static
50842bdc
PP		 253int bt_field_type_variant_compare(struct bt_field_type *,
254 struct bt_field_type *);
265e809c 255static
50842bdc
PP		 256int bt_field_type_array_compare(struct bt_field_type *,
257 struct bt_field_type *);
265e809c 258static
50842bdc
PP		 259int bt_field_type_sequence_compare(struct bt_field_type *,
260 struct bt_field_type *);
265e809c
PP		 261
262static
50842bdc
PP		 263int (* const type_compare_funcs[])(struct bt_field_type *,
264 struct bt_field_type *) = {
265 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_compare,
266 [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_compare,
267 [BT_FIELD_TYPE_ID_FLOAT] = bt_field_type_floating_point_compare,
268 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_compare,
269 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_compare,
270 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_compare,
271 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_compare,
272 [BT_FIELD_TYPE_ID_STRING] = bt_field_type_string_compare,
265e809c
PP		 273};
274
b3dbeb52 275static
50842bdc 276int bt_field_type_integer_validate(struct bt_field_type *);
81e36fac 277static
50842bdc 278int bt_field_type_enumeration_validate(struct bt_field_type *);
81e36fac 279static
50842bdc 280int bt_field_type_structure_validate(struct bt_field_type *);
81e36fac 281static
50842bdc 282int bt_field_type_variant_validate(struct bt_field_type *);
81e36fac 283static
50842bdc 284int bt_field_type_array_validate(struct bt_field_type *);
81e36fac 285static
50842bdc 286int bt_field_type_sequence_validate(struct bt_field_type *);
81e36fac
PP		 287
288static
50842bdc
PP		 289int (* const type_validate_funcs[])(struct bt_field_type *) = {
290 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_type_integer_validate,
291 [BT_FIELD_TYPE_ID_FLOAT] = NULL,
292 [BT_FIELD_TYPE_ID_STRING] = NULL,
293 [BT_FIELD_TYPE_ID_ENUM] = bt_field_type_enumeration_validate,
294 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_type_structure_validate,
295 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_type_variant_validate,
296 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_type_array_validate,
297 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_type_sequence_validate,
81e36fac
PP		 298};
299
273b65be
JG		 300static
301void destroy_enumeration_mapping(struct enumeration_mapping *mapping)
302{
303 g_free(mapping);
304}
305
306static
307void destroy_structure_field(struct structure_field *field)
308{
34462b62
PP		 309 if (!field) {
310 return;
311 }
312
313 BT_LOGD("Destroying structure/variant field type's field object: "
314 "addr=%p, field-ft-addr=%p, field-name=\"%s\"",
315 field, field->type, g_quark_to_string(field->name));
ec159b1e 316 BT_LOGD_STR("Putting field type.");
83509119 317 bt_put(field->type);
273b65be
JG		 318 g_free(field);
319}
320
321static
322void check_ranges_overlap(gpointer element, gpointer query)
323{
324 struct enumeration_mapping *mapping = element;
325 struct range_overlap_query *overlap_query = query;
326
b92ddaaa 327 if (mapping->range_start._signed <= overlap_query->range_end._signed
4e8304f7
PP		 328 && overlap_query->range_start._signed <=
329 mapping->range_end._signed) {
b92ddaaa
JG		 330 overlap_query->overlaps = 1;
331 overlap_query->mapping_name = mapping->string;
332 }
333
334 overlap_query->overlaps |=
335 mapping->string == overlap_query->mapping_name;
4e8304f7
PP		 336
337 if (overlap_query->overlaps) {
338 BT_LOGV("Overlapping enumeration field type mappings: "
339 "mapping-name=\"%s\", "
340 "mapping-a-range-start=%" PRId64 ", "
341 "mapping-a-range-end=%" PRId64 ", "
342 "mapping-b-range-start=%" PRId64 ", "
343 "mapping-b-range-end=%" PRId64,
344 g_quark_to_string(mapping->string),
345 mapping->range_start._signed,
346 mapping->range_end._signed,
347 overlap_query->range_start._signed,
348 overlap_query->range_end._signed);
349 }
b92ddaaa
JG		 350}
351
352static
353void check_ranges_overlap_unsigned(gpointer element, gpointer query)
354{
355 struct enumeration_mapping *mapping = element;
356 struct range_overlap_query *overlap_query = query;
357
358 if (mapping->range_start._unsigned <= overlap_query->range_end._unsigned
4e8304f7
PP		 359 && overlap_query->range_start._unsigned <=
360 mapping->range_end._unsigned) {
273b65be
JG		 361 overlap_query->overlaps = 1;
362 overlap_query->mapping_name = mapping->string;
363 }
364
365 overlap_query->overlaps |=
366 mapping->string == overlap_query->mapping_name;
4e8304f7
PP		 367
368 if (overlap_query->overlaps) {
369 BT_LOGW("Overlapping enumeration field type mappings: "
370 "mapping-name=\"%s\", "
371 "mapping-a-range-start=%" PRIu64 ", "
372 "mapping-a-range-end=%" PRIu64 ", "
373 "mapping-b-range-start=%" PRIu64 ", "
374 "mapping-b-range-end=%" PRIu64,
375 g_quark_to_string(mapping->string),
376 mapping->range_start._unsigned,
377 mapping->range_end._unsigned,
378 overlap_query->range_start._unsigned,
379 overlap_query->range_end._unsigned);
380 }
273b65be
JG		 381}
382
b92ddaaa
JG		 383static
384gint compare_enumeration_mappings_signed(struct enumeration_mapping **a,
385 struct enumeration_mapping **b)
386{
387 return ((*a)->range_start._signed < (*b)->range_start._signed) ? -1 : 1;
388}
389
390static
391gint compare_enumeration_mappings_unsigned(struct enumeration_mapping **a,
392 struct enumeration_mapping **b)
393{
394 return ((*a)->range_start._unsigned < (*b)->range_start._unsigned) ? -1 : 1;
395}
396
273b65be 397static
50842bdc 398void bt_field_type_init(struct bt_field_type *type, bt_bool init_bo)
273b65be 399{
50842bdc
PP		 400 assert(type && (type->id > BT_FIELD_TYPE_ID_UNKNOWN) &&
401 (type->id < BT_FIELD_TYPE_ID_NR));
273b65be 402
50842bdc 403 bt_object_init(type, bt_field_type_destroy);
dc3fffef
PP		 404 type->freeze = type_freeze_funcs[type->id];
405 type->serialize = type_serialize_funcs[type->id];
59acd4f5
PP		 406
407 if (init_bo) {
ec159b1e 408 int ret;
50842bdc 409 const enum bt_byte_order bo = BT_BYTE_ORDER_NATIVE;
ec159b1e
PP		 410
411 BT_LOGD("Setting initial field type's byte order: bo=%s",
50842bdc
PP		 412 bt_byte_order_string(bo));
413 ret = bt_field_type_set_byte_order(type, bo);
dc3fffef 414 assert(ret == 0);
59acd4f5
PP		 415 }
416
dc3fffef 417 type->alignment = 1;
273b65be
JG		 418}
419
420static
421int add_structure_field(GPtrArray *fields,
422 GHashTable *field_name_to_index,
50842bdc 423 struct bt_field_type *field_type,
273b65be
JG		 424 const char *field_name)
425{
426 int ret = 0;
427 GQuark name_quark = g_quark_from_string(field_name);
428 struct structure_field *field;
429
430 /* Make sure structure does not contain a field of the same name */
fe0fe95c 431 if (g_hash_table_lookup_extended(field_name_to_index,
4e8304f7
PP		 432 GUINT_TO_POINTER(name_quark), NULL, NULL)) {
433 BT_LOGW("Structure or variant field type already contains a field type with this name: "
434 "field-name=\"%s\"", field_name);
273b65be
JG		 435 ret = -1;
436 goto end;
437 }
438
439 field = g_new0(struct structure_field, 1);
440 if (!field) {
4e8304f7 441 BT_LOGE_STR("Failed to allocate one structure/variant field type field.");
273b65be
JG		 442 ret = -1;
443 goto end;
444 }
445
83509119 446 bt_get(field_type);
273b65be
JG		 447 field->name = name_quark;
448 field->type = field_type;
449 g_hash_table_insert(field_name_to_index,
5b44aff2
MJ		 450 GUINT_TO_POINTER(name_quark),
451 GUINT_TO_POINTER(fields->len));
273b65be 452 g_ptr_array_add(fields, field);
dfc1504d
PP		 453 BT_LOGV("Added structure/variant field type field: field-ft-addr=%p, "
454 "field-name=\"%s\"", field_type, field_name);
273b65be
JG		 455end:
456 return ret;
457}
458
2f2d8e05 459static
50842bdc 460void bt_field_type_destroy(struct bt_object *obj)
2f2d8e05 461{
50842bdc
PP		 462 struct bt_field_type *type;
463 enum bt_field_type_id type_id;
2f2d8e05 464
50842bdc 465 type = container_of(obj, struct bt_field_type, base);
dc3fffef 466 type_id = type->id;
50842bdc
PP		 467 assert(type_id > BT_FIELD_TYPE_ID_UNKNOWN &&
468 type_id < BT_FIELD_TYPE_ID_NR);
de3dd40e 469 type_destroy_funcs[type_id](type);
2f2d8e05
JG		 470}
471
b3dbeb52 472static
50842bdc 473int bt_field_type_integer_validate(struct bt_field_type *type)
b3dbeb52
PP		 474{
475 int ret = 0;
476
50842bdc
PP		 477 struct bt_field_type_integer *integer =
478 container_of(type, struct bt_field_type_integer,
b3dbeb52
PP		 479 parent);
480
dc3fffef 481 if (integer->mapped_clock && integer->is_signed) {
4e8304f7
PP		 482 BT_LOGW("Invalid integer field type: cannot be signed and have a mapped clock class: "
483 "ft-addr=%p, clock-class-addr=%p, clock-class-name=\"%s\"",
484 type, integer->mapped_clock,
50842bdc 485 bt_clock_class_get_name(integer->mapped_clock));
b3dbeb52
PP		 486 ret = -1;
487 goto end;
488 }
489
490end:
491 return ret;
492}
493
d49e1284
JG		 494static
495struct enumeration_mapping *get_enumeration_mapping(
50842bdc 496 struct bt_field_type *type, uint64_t index)
d49e1284
JG		 497{
498 struct enumeration_mapping *mapping = NULL;
50842bdc 499 struct bt_field_type_enumeration *enumeration;
d49e1284 500
50842bdc 501 enumeration = container_of(type, struct bt_field_type_enumeration,
d49e1284
JG		 502 parent);
503 if (index >= enumeration->entries->len) {
4e8304f7
PP		 504 BT_LOGW("Invalid parameter: index is out of bounds: "
505 "addr=%p, index=%" PRIu64 ", count=%u",
506 type, index, enumeration->entries->len);
d49e1284
JG		 507 goto end;
508 }
509
510 mapping = g_ptr_array_index(enumeration->entries, index);
511end:
512 return mapping;
513}
514
515/*
516 * Note: This algorithm is O(n^2) vs number of enumeration mappings.
517 * Only used when freezing an enumeration.
518 */
519static
520void set_enumeration_range_overlap(
50842bdc 521 struct bt_field_type *type)
d49e1284 522{
4e8304f7 523 int64_t i, j, len;
50842bdc
PP		 524 struct bt_field_type *container_type;
525 struct bt_field_type_enumeration *enumeration_type;
d49e1284
JG		 526 int is_signed;
527
4e8304f7
PP		 528 BT_LOGV("Setting enumeration field type's overlap flag: addr=%p",
529 type);
d49e1284 530 enumeration_type = container_of(type,
50842bdc 531 struct bt_field_type_enumeration, parent);
d49e1284
JG		 532
533 len = enumeration_type->entries->len;
534 container_type = enumeration_type->container;
50842bdc 535 is_signed = bt_field_type_integer_is_signed(container_type);
d49e1284
JG		 536
537 for (i = 0; i < len; i++) {
538 for (j = i + 1; j < len; j++) {
539 struct enumeration_mapping *mapping[2];
540
541 mapping[0] = get_enumeration_mapping(type, i);
542 mapping[1] = get_enumeration_mapping(type, j);
543 if (is_signed) {
544 if (mapping[0]->range_start._signed
545 <= mapping[1]->range_end._signed
546 && mapping[0]->range_end._signed
547 >= mapping[1]->range_start._signed) {
c55a9f58 548 enumeration_type->has_overlapping_ranges = BT_TRUE;
dfc1504d 549 goto end;
d49e1284
JG		 550 }
551 } else {
552 if (mapping[0]->range_start._unsigned
553 <= mapping[1]->range_end._unsigned
554 && mapping[0]->range_end._unsigned
555 >= mapping[1]->range_start._unsigned) {
c55a9f58 556 enumeration_type->has_overlapping_ranges = BT_TRUE;
dfc1504d 557 goto end;
d49e1284
JG		 558 }
559 }
560 }
561 }
dfc1504d
PP		 562
563end:
564 if (enumeration_type->has_overlapping_ranges) {
565 BT_LOGV_STR("Enumeration field type has overlapping ranges.");
566 } else {
567 BT_LOGV_STR("Enumeration field type has no overlapping ranges.");
568 }
d49e1284
JG		 569}
570
81e36fac 571static
50842bdc 572int bt_field_type_enumeration_validate(struct bt_field_type *type)
9ce21c30
JG		 573{
574 int ret = 0;
575
50842bdc
PP		 576 struct bt_field_type_enumeration *enumeration =
577 container_of(type, struct bt_field_type_enumeration,
81e36fac 578 parent);
50842bdc
PP		 579 struct bt_field_type *container_type =
580 bt_field_type_enumeration_get_container_type(type);
81e36fac 581
4e8304f7 582 assert(container_type);
50842bdc 583 ret = bt_field_type_validate(container_type);
81e36fac 584 if (ret) {
4e8304f7
PP		 585 BT_LOGW("Invalid enumeration field type: container type is invalid: "
586 "enum-ft-addr=%p, int-ft-addr=%p",
587 type, container_type);
81e36fac
PP		 588 goto end;
589 }
9ce21c30 590
81e36fac 591 /* Ensure enum has entries */
4e8304f7
PP		 592 if (enumeration->entries->len == 0) {
593 BT_LOGW("Invalid enumeration field type: no entries: "
594 "addr=%p", type);
595 ret = -1;
596 goto end;
597 }
81e36fac
PP		 598
599end:
600 BT_PUT(container_type);
601 return ret;
602}
603
604static
50842bdc 605int bt_field_type_sequence_validate(struct bt_field_type *type)
81e36fac
PP		 606{
607 int ret = 0;
50842bdc
PP		 608 struct bt_field_type *element_type = NULL;
609 struct bt_field_type_sequence *sequence =
610 container_of(type, struct bt_field_type_sequence,
81e36fac
PP		 611 parent);
612
613 /* Length field name should be set at this point */
614 if (sequence->length_field_name->len == 0) {
4e8304f7
PP		 615 BT_LOGW("Invalid sequence field type: no length field name: "
616 "addr=%p", type);
81e36fac
PP		 617 ret = -1;
618 goto end;
5d161ecc 619 }
81e36fac 620
50842bdc 621 element_type = bt_field_type_sequence_get_element_type(type);
4e8304f7 622 assert(element_type);
50842bdc 623 ret = bt_field_type_validate(element_type);
4e8304f7
PP		 624 if (ret) {
625 BT_LOGW("Invalid sequence field type: invalid element field type: "
626 "seq-ft-addr=%p, element-ft-add=%p",
627 type, element_type);
628 }
81e36fac
PP		 629
630end:
631 BT_PUT(element_type);
632
633 return ret;
634}
635
636static
50842bdc 637int bt_field_type_array_validate(struct bt_field_type *type)
81e36fac
PP		 638{
639 int ret = 0;
50842bdc 640 struct bt_field_type *element_type = NULL;
81e36fac 641
50842bdc 642 element_type = bt_field_type_array_get_element_type(type);
4e8304f7 643 assert(element_type);
50842bdc 644 ret = bt_field_type_validate(element_type);
4e8304f7
PP		 645 if (ret) {
646 BT_LOGW("Invalid array field type: invalid element field type: "
647 "array-ft-addr=%p, element-ft-add=%p",
648 type, element_type);
649 }
81e36fac 650
81e36fac 651 BT_PUT(element_type);
81e36fac
PP		 652 return ret;
653}
654
655static
50842bdc 656int bt_field_type_structure_validate(struct bt_field_type *type)
81e36fac
PP		 657{
658 int ret = 0;
50842bdc
PP		 659 struct bt_field_type *child_type = NULL;
660 int64_t field_count = bt_field_type_structure_get_field_count(type);
544d0515 661 int64_t i;
81e36fac 662
4e8304f7 663 assert(field_count >= 0);
81e36fac
PP		 664
665 for (i = 0; i < field_count; ++i) {
4e8304f7 666 const char *field_name;
81e36fac 667
50842bdc 668 ret = bt_field_type_structure_get_field_by_index(type,
4e8304f7
PP		 669 &field_name, &child_type, i);
670 assert(ret == 0);
50842bdc 671 ret = bt_field_type_validate(child_type);
81e36fac 672 if (ret) {
4e8304f7
PP		 673 BT_LOGW("Invalid structure field type: "
674 "a contained field type is invalid: "
675 "struct-ft-addr=%p, field-ft-addr=%p, "
676 "field-name=\"%s\", field-index=%" PRId64,
677 type, child_type, field_name, i);
81e36fac
PP		 678 goto end;
679 }
680
681 BT_PUT(child_type);
682 }
683
684end:
685 BT_PUT(child_type);
686
687 return ret;
688}
689
96e8f959 690static
50842bdc
PP		 691bt_bool bt_field_type_enumeration_has_overlapping_ranges(
692 struct bt_field_type_enumeration *enumeration_type)
96e8f959 693{
d49e1284
JG		 694 if (!enumeration_type->parent.frozen) {
695 set_enumeration_range_overlap(&enumeration_type->parent);
696 }
96e8f959
MD		 697 return enumeration_type->has_overlapping_ranges;
698}
699
81e36fac 700static
50842bdc 701int bt_field_type_variant_validate(struct bt_field_type *type)
81e36fac
PP		 702{
703 int ret = 0;
544d0515 704 int64_t field_count;
50842bdc
PP		 705 struct bt_field_type *child_type = NULL;
706 struct bt_field_type_variant *variant =
707 container_of(type, struct bt_field_type_variant,
c6c0ca42 708 parent);
544d0515 709 int64_t i;
c6c0ca42 710
4e8304f7
PP		 711 if (variant->tag_name->len == 0) {
712 BT_LOGW("Invalid variant field type: no tag field name: "
713 "addr=%p", type);
714 ret = -1;
715 goto end;
716 }
717
718 if (!variant->tag) {
719 BT_LOGW("Invalid variant field type: no tag field type: "
720 "addr=%p, tag-field-name=\"%s\"", type,
721 variant->tag_name->str);
81e36fac
PP		 722 ret = -1;
723 goto end;
724 }
725
50842bdc 726 if (bt_field_type_enumeration_has_overlapping_ranges(
96e8f959 727 variant->tag)) {
4e8304f7
PP		 728 BT_LOGW("Invalid variant field type: enumeration tag field type has overlapping ranges: "
729 "variant-ft-addr=%p, tag-field-name=\"%s\", "
730 "enum-ft-addr=%p", type, variant->tag_name->str,
731 variant->tag);
96e8f959
MD		 732 ret = -1;
733 goto end;
734 }
735
e9eb537e 736 /*
2d4b0539
MD		 737 * It is valid to have a variant field type which does not have
738 * the fields corresponding to each label in the associated
739 * enumeration.
e9eb537e 740 *
2d4b0539
MD		 741 * It is also valid to have variant field type fields which
742 * cannot be selected because the variant field type tag has no
743 * mapping named as such. This scenario, while not ideal, cannot
744 * cause any error.
745 *
746 * If a non-existing field happens to be selected by an
747 * enumeration while reading a variant field, an error will be
748 * generated at that point (while reading the stream).
e9eb537e 749 */
50842bdc 750 field_count = bt_field_type_variant_get_field_count(type);
81e36fac 751 if (field_count < 0) {
4e8304f7
PP		 752 BT_LOGW("Invalid variant field type: no fields: "
753 "addr=%p, tag-field-name=\"%s\"",
754 type, variant->tag_name->str);
81e36fac
PP		 755 ret = -1;
756 goto end;
757 }
758
759 for (i = 0; i < field_count; ++i) {
4e8304f7 760 const char *field_name;
81e36fac 761
50842bdc 762 ret = bt_field_type_variant_get_field_by_index(type,
4e8304f7
PP		 763 &field_name, &child_type, i);
764 assert(ret == 0);
50842bdc 765 ret = bt_field_type_validate(child_type);
81e36fac 766 if (ret) {
4e8304f7
PP		 767 BT_LOGW("Invalid variant field type: "
768 "a contained field type is invalid: "
769 "variant-ft-addr=%p, tag-field-name=\"%s\", "
770 "field-ft-addr=%p, field-name=\"%s\", "
771 "field-index=%" PRId64,
772 type, variant->tag_name->str, child_type,
773 field_name, i);
81e36fac
PP		 774 goto end;
775 }
776
777 BT_PUT(child_type);
778 }
779
780end:
781 BT_PUT(child_type);
782
783 return ret;
784}
785
786/*
787 * This function validates a given field type without considering
788 * where this field type is located. It only validates the properties
789 * of the given field type and the properties of its children if
790 * applicable.
791 */
792BT_HIDDEN
50842bdc 793int bt_field_type_validate(struct bt_field_type *type)
81e36fac
PP		 794{
795 int ret = 0;
50842bdc 796 enum bt_field_type_id id = bt_field_type_get_type_id(type);
81e36fac 797
4e8304f7 798 assert(type);
81e36fac
PP		 799
800 if (type->valid) {
801 /* Already marked as valid */
802 goto end;
803 }
804
805 if (type_validate_funcs[id]) {
806 ret = type_validate_funcs[id](type);
807 }
808
809 if (!ret && type->frozen) {
810 /* Field type is valid */
ec159b1e 811 BT_LOGV("Marking field type as valid: addr=%p", type);
81e36fac
PP		 812 type->valid = 1;
813 }
814
9ce21c30
JG		 815end:
816 return ret;
817}
818
50842bdc 819struct bt_field_type *bt_field_type_integer_create(unsigned int size)
273b65be 820{
50842bdc
PP		 821 struct bt_field_type_integer *integer =
822 g_new0(struct bt_field_type_integer, 1);
273b65be 823
4e8304f7
PP		 824 BT_LOGD("Creating integer field type object: size=%u", size);
825
826 if (!integer) {
827 BT_LOGE_STR("Failed to allocate one integer field type.");
828 return NULL;
829 }
830
831 if (size == 0 || size > 64) {
832 BT_LOGW("Invalid parameter: size must be between 1 and 64: "
833 "size=%u", size);
273b65be
JG		 834 return NULL;
835 }
836
50842bdc 837 integer->parent.id = BT_FIELD_TYPE_ID_INTEGER;
dc3fffef 838 integer->size = size;
50842bdc
PP		 839 integer->base = BT_INTEGER_BASE_DECIMAL;
840 integer->encoding = BT_STRING_ENCODING_NONE;
841 bt_field_type_init(&integer->parent, TRUE);
4e8304f7
PP		 842 BT_LOGD("Created integer field type object: addr=%p, size=%u",
843 &integer->parent, size);
273b65be
JG		 844 return &integer->parent;
845}
846
50842bdc 847int bt_field_type_integer_get_size(struct bt_field_type *type)
b92ddaaa
JG		 848{
849 int ret = 0;
50842bdc 850 struct bt_field_type_integer *integer;
b92ddaaa 851
4e8304f7
PP		 852 if (!type) {
853 BT_LOGW_STR("Invalid parameter: field type is NULL.");
854 ret = -1;
855 goto end;
856 }
857
50842bdc 858 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 859 BT_LOGW("Invalid parameter: field type is not an integer field type: "
860 "addr=%p, ft-id=%s", type,
50842bdc 861 bt_field_type_id_string(type->id));
b92ddaaa
JG		 862 ret = -1;
863 goto end;
864 }
865
50842bdc 866 integer = container_of(type, struct bt_field_type_integer, parent);
dc3fffef 867 ret = (int) integer->size;
b92ddaaa
JG		 868end:
869 return ret;
870}
871
50842bdc 872int bt_ctf_field_type_integer_get_signed(struct bt_field_type *type)
b92ddaaa
JG		 873{
874 int ret = 0;
50842bdc 875 struct bt_field_type_integer *integer;
b92ddaaa 876
4e8304f7
PP		 877 if (!type) {
878 BT_LOGW_STR("Invalid parameter: field type is NULL.");
879 ret = -1;
880 goto end;
881 }
882
50842bdc 883 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 884 BT_LOGW("Invalid parameter: field type is not an integer field type: "
885 "addr=%p, ft-id=%s", type,
50842bdc 886 bt_field_type_id_string(type->id));
b92ddaaa
JG		 887 ret = -1;
888 goto end;
889 }
890
50842bdc 891 integer = container_of(type, struct bt_field_type_integer, parent);
dc3fffef 892 ret = integer->is_signed;
b92ddaaa
JG		 893end:
894 return ret;
895}
896
50842bdc
PP		 897bt_bool bt_field_type_integer_is_signed(
898 struct bt_field_type *int_field_type)
c14d64fa
PP		 899{
900 return bt_ctf_field_type_integer_get_signed(int_field_type) ?
901 BT_TRUE : BT_FALSE;
902}
903
50842bdc 904int bt_field_type_integer_set_is_signed(struct bt_field_type *type,
c14d64fa 905 bt_bool is_signed)
273b65be
JG		 906{
907 int ret = 0;
50842bdc 908 struct bt_field_type_integer *integer;
273b65be 909
4e8304f7
PP		 910 if (!type) {
911 BT_LOGW_STR("Invalid parameter: field type is NULL.");
912 ret = -1;
913 goto end;
914 }
915
916 if (type->frozen) {
917 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
918 type);
919 ret = -1;
920 goto end;
921 }
922
50842bdc 923 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 924 BT_LOGW("Invalid parameter: field type is not an integer field type: "
925 "addr=%p, ft-id=%s", type,
50842bdc 926 bt_field_type_id_string(type->id));
273b65be
JG		 927 ret = -1;
928 goto end;
929 }
930
50842bdc 931 integer = container_of(type, struct bt_field_type_integer, parent);
dc3fffef 932 integer->is_signed = !!is_signed;
dfc1504d
PP		 933 BT_LOGV("Set integer field type's signedness: addr=%p, is-signed=%d",
934 type, is_signed);
273b65be
JG		 935end:
936 return ret;
937}
938
50842bdc 939int bt_field_type_integer_set_size(struct bt_field_type *type,
3bc8ebda 940 unsigned int size)
c3c35de4
JD		 941{
942 int ret = 0;
50842bdc 943 struct bt_field_type_integer *integer;
c3c35de4 944
4e8304f7
PP		 945 if (!type) {
946 BT_LOGW_STR("Invalid parameter: field type is NULL.");
947 ret = -1;
948 goto end;
949 }
950
951 if (type->frozen) {
952 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
953 type);
954 ret = -1;
955 goto end;
956 }
957
50842bdc 958 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 959 BT_LOGW("Invalid parameter: field type is not an integer field type: "
960 "addr=%p, ft-id=%s", type,
50842bdc 961 bt_field_type_id_string(type->id));
4e8304f7
PP		 962 ret = -1;
963 goto end;
964 }
965
966 if (size == 0 || size > 64) {
967 BT_LOGW("Invalid parameter: size must be between 1 and 64: "
3bc8ebda 968 "addr=%p, size=%u", type, size);
c3c35de4
JD		 969 ret = -1;
970 goto end;
971 }
972
50842bdc 973 integer = container_of(type, struct bt_field_type_integer, parent);
c3c35de4 974 integer->size = size;
3bc8ebda 975 BT_LOGV("Set integer field type's size: addr=%p, size=%u",
dfc1504d 976 type, size);
c3c35de4
JD		 977end:
978 return ret;
979}
980
50842bdc
PP		 981enum bt_integer_base bt_field_type_integer_get_base(
982 struct bt_field_type *type)
b92ddaaa 983{
50842bdc
PP		 984 enum bt_integer_base ret = BT_INTEGER_BASE_UNKNOWN;
985 struct bt_field_type_integer *integer;
b92ddaaa 986
4e8304f7
PP		 987 if (!type) {
988 BT_LOGW_STR("Invalid parameter: field type is NULL.");
989 goto end;
990 }
991
50842bdc 992 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 993 BT_LOGW("Invalid parameter: field type is not an integer field type: "
994 "addr=%p, ft-id=%s", type,
50842bdc 995 bt_field_type_id_string(type->id));
b92ddaaa
JG		 996 goto end;
997 }
998
50842bdc 999 integer = container_of(type, struct bt_field_type_integer, parent);
dc3fffef 1000 ret = integer->base;
b92ddaaa
JG		 1001end:
1002 return ret;
1003}
1004
50842bdc
PP		 1005int bt_field_type_integer_set_base(struct bt_field_type *type,
1006 enum bt_integer_base base)
273b65be
JG		 1007{
1008 int ret = 0;
1009
4e8304f7
PP		 1010 if (!type) {
1011 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1012 ret = -1;
1013 goto end;
1014 }
1015
1016 if (type->frozen) {
1017 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1018 type);
1019 ret = -1;
1020 goto end;
1021 }
1022
50842bdc 1023 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 1024 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1025 "addr=%p, ft-id=%s", type,
50842bdc 1026 bt_field_type_id_string(type->id));
273b65be
JG		 1027 ret = -1;
1028 goto end;
1029 }
1030
1031 switch (base) {
50842bdc
PP		 1032 case BT_INTEGER_BASE_UNSPECIFIED:
1033 case BT_INTEGER_BASE_BINARY:
1034 case BT_INTEGER_BASE_OCTAL:
1035 case BT_INTEGER_BASE_DECIMAL:
1036 case BT_INTEGER_BASE_HEXADECIMAL:
273b65be 1037 {
50842bdc
PP		 1038 struct bt_field_type_integer *integer = container_of(type,
1039 struct bt_field_type_integer, parent);
dc3fffef 1040 integer->base = base;
273b65be
JG		 1041 break;
1042 }
1043 default:
4e8304f7
PP		 1044 BT_LOGW("Invalid parameter: unknown integer field type base: "
1045 "addr=%p, base=%d", type, base);
273b65be
JG		 1046 ret = -1;
1047 }
dfc1504d
PP		 1048
1049 BT_LOGV("Set integer field type's base: addr=%p, base=%s",
50842bdc 1050 type, bt_integer_base_string(base));
dfc1504d 1051
273b65be
JG		 1052end:
1053 return ret;
1054}
1055
50842bdc
PP		 1056enum bt_string_encoding bt_field_type_integer_get_encoding(
1057 struct bt_field_type *type)
b92ddaaa 1058{
50842bdc
PP		 1059 enum bt_string_encoding ret = BT_STRING_ENCODING_UNKNOWN;
1060 struct bt_field_type_integer *integer;
b92ddaaa 1061
4e8304f7
PP		 1062 if (!type) {
1063 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1064 goto end;
1065 }
1066
50842bdc 1067 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 1068 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1069 "addr=%p, ft-id=%s", type,
50842bdc 1070 bt_field_type_id_string(type->id));
b92ddaaa
JG		 1071 goto end;
1072 }
1073
50842bdc 1074 integer = container_of(type, struct bt_field_type_integer, parent);
dc3fffef 1075 ret = integer->encoding;
b92ddaaa
JG		 1076end:
1077 return ret;
1078}
1079
50842bdc
PP		 1080int bt_field_type_integer_set_encoding(struct bt_field_type *type,
1081 enum bt_string_encoding encoding)
273b65be
JG		 1082{
1083 int ret = 0;
50842bdc 1084 struct bt_field_type_integer *integer;
273b65be 1085
4e8304f7
PP		 1086 if (!type) {
1087 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1088 ret = -1;
1089 goto end;
1090 }
1091
1092 if (type->frozen) {
1093 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1094 type);
1095 ret = -1;
1096 goto end;
1097 }
1098
50842bdc 1099 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 1100 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1101 "addr=%p, ft-id=%s", type,
50842bdc 1102 bt_field_type_id_string(type->id));
4e8304f7
PP		 1103 ret = -1;
1104 goto end;
1105 }
1106
50842bdc
PP		 1107 if (encoding != BT_STRING_ENCODING_UTF8 &&
1108 encoding != BT_STRING_ENCODING_ASCII &&
1109 encoding != BT_STRING_ENCODING_NONE) {
4e8304f7
PP		 1110 BT_LOGW("Invalid parameter: unknown string encoding: "
1111 "addr=%p, encoding=%d", type, encoding);
273b65be
JG		 1112 ret = -1;
1113 goto end;
1114 }
1115
50842bdc 1116 integer = container_of(type, struct bt_field_type_integer, parent);
dc3fffef 1117 integer->encoding = encoding;
dfc1504d 1118 BT_LOGV("Set integer field type's encoding: addr=%p, encoding=%s",
50842bdc 1119 type, bt_string_encoding_string(encoding));
273b65be
JG		 1120end:
1121 return ret;
1122}
1123
50842bdc
PP		 1124struct bt_clock_class *bt_field_type_integer_get_mapped_clock_class(
1125 struct bt_field_type *type)
6cfb906f 1126{
50842bdc
PP		 1127 struct bt_field_type_integer *integer;
1128 struct bt_clock_class *clock_class = NULL;
6cfb906f
JG		 1129
1130 if (!type) {
4e8304f7 1131 BT_LOGW_STR("Invalid parameter: field type is NULL.");
6cfb906f
JG		 1132 goto end;
1133 }
1134
50842bdc 1135 integer = container_of(type, struct bt_field_type_integer, parent);
ac0c6bdd
PP		 1136 clock_class = integer->mapped_clock;
1137 bt_get(clock_class);
6cfb906f 1138end:
ac0c6bdd 1139 return clock_class;
6cfb906f
JG		 1140}
1141
e011d2c1 1142BT_HIDDEN
50842bdc
PP		 1143int bt_field_type_integer_set_mapped_clock_class_no_check(
1144 struct bt_field_type *type,
1145 struct bt_clock_class *clock_class)
6cfb906f 1146{
50842bdc 1147 struct bt_field_type_integer *integer;
6cfb906f
JG		 1148 int ret = 0;
1149
4e8304f7
PP		 1150 if (!type) {
1151 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1152 ret = -1;
1153 goto end;
1154 }
1155
1156 if (!clock_class) {
1157 BT_LOGW_STR("Invalid parameter: clock class is NULL.");
1158 ret = -1;
1159 goto end;
1160 }
1161
50842bdc 1162 if (type->id != BT_FIELD_TYPE_ID_INTEGER) {
e011d2c1
PP		 1163 BT_LOGW("Invalid parameter: field type is not an integer field type: "
1164 "addr=%p, ft-id=%s", type,
50842bdc 1165 bt_field_type_id_string(type->id));
4e8304f7
PP		 1166 goto end;
1167 }
1168
50842bdc 1169 if (!bt_clock_class_is_valid(clock_class)) {
4e8304f7
PP		 1170 BT_LOGW("Invalid parameter: clock class is invalid: ft-addr=%p"
1171 "clock-class-addr=%p, clock-class-name=\"%s\"",
1172 type, clock_class,
50842bdc 1173 bt_clock_class_get_name(clock_class));
6cfb906f
JG		 1174 ret = -1;
1175 goto end;
1176 }
1177
50842bdc 1178 integer = container_of(type, struct bt_field_type_integer, parent);
83509119 1179 bt_put(integer->mapped_clock);
ac0c6bdd 1180 integer->mapped_clock = bt_get(clock_class);
dfc1504d
PP		 1181 BT_LOGV("Set integer field type's mapped clock class: ft-addr=%p, "
1182 "clock-class-addr=%p, clock-class-name=\"%s\"",
50842bdc 1183 type, clock_class, bt_clock_class_get_name(clock_class));
6cfb906f
JG		 1184end:
1185 return ret;
1186}
1187
50842bdc
PP		 1188int bt_field_type_integer_set_mapped_clock_class(
1189 struct bt_field_type *type,
1190 struct bt_clock_class *clock_class)
e011d2c1
PP		 1191{
1192 int ret = 0;
1193
1194 if (!type) {
1195 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1196 ret = -1;
1197 goto end;
1198 }
1199
1200 if (type->frozen) {
1201 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1202 type);
1203 ret = -1;
1204 goto end;
1205 }
1206
50842bdc 1207 ret = bt_field_type_integer_set_mapped_clock_class_no_check(
e011d2c1
PP		 1208 type, clock_class);
1209
1210end:
1211 return ret;
1212}
1213
96e8f959 1214static
50842bdc 1215void bt_field_type_enum_iter_destroy(struct bt_object *obj)
96e8f959 1216{
50842bdc 1217 struct bt_field_type_enumeration_mapping_iterator *iter =
d49e1284 1218 container_of(obj,
50842bdc 1219 struct bt_field_type_enumeration_mapping_iterator,
d49e1284 1220 base);
96e8f959 1221
ec159b1e
PP		 1222 BT_LOGD("Destroying enumeration field type mapping iterator: addr=%p",
1223 obj);
1224 BT_LOGD_STR("Putting parent enumeration field type.");
d49e1284
JG		 1225 bt_put(&iter->enumeration_type->parent);
1226 g_free(iter);
1227}
1228
1229static
50842bdc
PP		 1230struct bt_field_type_enumeration_mapping_iterator *
1231bt_field_type_enumeration_find_mappings_type(
1232 struct bt_field_type *type,
1233 enum bt_field_type_enumeration_mapping_iterator_type iterator_type)
d49e1284 1234{
50842bdc
PP		 1235 struct bt_field_type_enumeration *enumeration_type;
1236 struct bt_field_type_enumeration_mapping_iterator *iter = NULL;
d49e1284 1237
4e8304f7
PP		 1238 if (!type) {
1239 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1240 goto end;
1241 }
1242
50842bdc 1243 if (type->id != BT_FIELD_TYPE_ID_ENUM) {
4e8304f7
PP		 1244 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1245 "addr=%p, ft-id=%s", type,
50842bdc 1246 bt_field_type_id_string(type->id));
96e8f959
MD		 1247 goto end;
1248 }
1249
d49e1284 1250 enumeration_type = container_of(type,
50842bdc
PP		 1251 struct bt_field_type_enumeration, parent);
1252 iter = g_new0(struct bt_field_type_enumeration_mapping_iterator, 1);
d49e1284 1253 if (!iter) {
4e8304f7 1254 BT_LOGE_STR("Failed to allocate one enumeration field type mapping.");
d49e1284
JG		 1255 goto end;
1256 }
1257
50842bdc 1258 bt_object_init(&iter->base, bt_field_type_enum_iter_destroy);
d49e1284
JG		 1259 bt_get(type);
1260 iter->enumeration_type = enumeration_type;
1261 iter->index = -1;
1262 iter->type = iterator_type;
96e8f959 1263end:
d49e1284 1264 return iter;
96e8f959
MD		 1265}
1266
50842bdc
PP		 1267struct bt_field_type_enumeration_mapping_iterator *
1268bt_field_type_enumeration_find_mappings_by_name(
1269 struct bt_field_type *type, const char *name)
96e8f959 1270{
50842bdc 1271 struct bt_field_type_enumeration_mapping_iterator *iter;
96e8f959 1272
50842bdc 1273 iter = bt_field_type_enumeration_find_mappings_type(
d49e1284
JG		 1274 type, ITERATOR_BY_NAME);
1275 if (!iter) {
4e8304f7
PP		 1276 BT_LOGE("Cannot create enumeration field type mapping iterator: "
1277 "ft-addr=%p, mapping-name=\"%s\"", type, name);
d49e1284
JG		 1278 goto error;
1279 }
1280
1281 iter->u.name_quark = g_quark_try_string(name);
1282 if (!iter->u.name_quark) {
74fb0452
JG		 1283 /*
1284 * No results are possible, set the iterator's position at the
1285 * end.
1286 */
1287 iter->index = iter->enumeration_type->entries->len;
d49e1284 1288 }
d49e1284
JG		 1289 return iter;
1290error:
1291 bt_put(iter);
1292 return NULL;
96e8f959
MD		 1293}
1294
50842bdc
PP		 1295int bt_field_type_enumeration_mapping_iterator_next(
1296 struct bt_field_type_enumeration_mapping_iterator *iter)
96e8f959 1297{
50842bdc
PP		 1298 struct bt_field_type_enumeration *enumeration;
1299 struct bt_field_type *type;
96e8f959
MD		 1300 int i, ret = 0, len;
1301
4e8304f7
PP		 1302 if (!iter) {
1303 BT_LOGW_STR("Invalid parameter: enumeration field type mapping iterator is NULL.");
1304 ret = -1;
1305 goto end;
1306 }
1307
96e8f959
MD		 1308 enumeration = iter->enumeration_type;
1309 type = &enumeration->parent;
1310 len = enumeration->entries->len;
1311 for (i = iter->index + 1; i < len; i++) {
1312 struct enumeration_mapping *mapping =
1313 get_enumeration_mapping(type, i);
1314
d49e1284 1315 switch (iter->type) {
96e8f959
MD		 1316 case ITERATOR_BY_NAME:
1317 if (mapping->string == iter->u.name_quark) {
1318 iter->index = i;
1319 goto end;
1320 }
1321 break;
1322 case ITERATOR_BY_SIGNED_VALUE:
1323 {
1324 int64_t value = iter->u.signed_value;
1325
1326 if (value >= mapping->range_start._signed &&
1327 value <= mapping->range_end._signed) {
1328 iter->index = i;
1329 goto end;
1330 }
1331 break;
1332 }
1333 case ITERATOR_BY_UNSIGNED_VALUE:
1334 {
1335 uint64_t value = iter->u.unsigned_value;
1336
1337 if (value >= mapping->range_start._unsigned &&
1338 value <= mapping->range_end._unsigned) {
1339 iter->index = i;
1340 goto end;
1341 }
1342 break;
1343 }
1344 default:
ec159b1e
PP		 1345 BT_LOGF("Invalid enumeration field type mapping iterator type: "
1346 "type=%d", iter->type);
96e8f959
MD		 1347 abort();
1348 }
1349 }
1350
1351 ret = -1;
1352end:
1353 return ret;
1354}
1355
50842bdc
PP		 1356struct bt_field_type_enumeration_mapping_iterator *
1357bt_field_type_enumeration_find_mappings_by_signed_value(
1358 struct bt_field_type *type, int64_t value)
96e8f959 1359{
50842bdc 1360 struct bt_field_type_enumeration_mapping_iterator *iter;
96e8f959 1361
50842bdc 1362 iter = bt_field_type_enumeration_find_mappings_type(
96e8f959
MD		 1363 type, ITERATOR_BY_SIGNED_VALUE);
1364 if (!iter) {
4e8304f7
PP		 1365 BT_LOGE("Cannot create enumeration field type mapping iterator: "
1366 "ft-addr=%p, value=%" PRId64, type, value);
96e8f959
MD		 1367 goto error;
1368 }
d49e1284 1369
96e8f959
MD		 1370 if (bt_ctf_field_type_integer_get_signed(
1371 iter->enumeration_type->container) != 1) {
4e8304f7
PP		 1372 BT_LOGW("Invalid parameter: enumeration field type is unsigned: "
1373 "enum-ft-addr=%p, int-ft-addr=%p",
1374 type, iter->enumeration_type->container);
96e8f959
MD		 1375 goto error;
1376 }
4e8304f7 1377
96e8f959 1378 iter->u.signed_value = value;
d49e1284 1379 return iter;
96e8f959
MD		 1380error:
1381 bt_put(iter);
1382 return NULL;
1383}
1384
50842bdc
PP		 1385struct bt_field_type_enumeration_mapping_iterator *
1386bt_field_type_enumeration_find_mappings_by_unsigned_value(
1387 struct bt_field_type *type, uint64_t value)
96e8f959 1388{
50842bdc 1389 struct bt_field_type_enumeration_mapping_iterator *iter;
96e8f959 1390
50842bdc 1391 iter = bt_field_type_enumeration_find_mappings_type(
96e8f959
MD		 1392 type, ITERATOR_BY_UNSIGNED_VALUE);
1393 if (!iter) {
4e8304f7
PP		 1394 BT_LOGE("Cannot create enumeration field type mapping iterator: "
1395 "ft-addr=%p, value=%" PRIu64, type, value);
96e8f959
MD		 1396 goto error;
1397 }
d49e1284 1398
96e8f959
MD		 1399 if (bt_ctf_field_type_integer_get_signed(
1400 iter->enumeration_type->container) != 0) {
4e8304f7
PP		 1401 BT_LOGW("Invalid parameter: enumeration field type is signed: "
1402 "enum-ft-addr=%p, int-ft-addr=%p",
1403 type, iter->enumeration_type->container);
96e8f959
MD		 1404 goto error;
1405 }
1406 iter->u.unsigned_value = value;
d49e1284 1407 return iter;
96e8f959
MD		 1408error:
1409 bt_put(iter);
1410 return NULL;
1411}
1412
50842bdc
PP		 1413int bt_field_type_enumeration_mapping_iterator_get_signed(
1414 struct bt_field_type_enumeration_mapping_iterator *iter,
d49e1284
JG		 1415 const char **mapping_name, int64_t *range_begin,
1416 int64_t *range_end)
1417{
1418 int ret = 0;
1419
1420 if (!iter) {
4e8304f7 1421 BT_LOGW_STR("Invalid parameter: enumeration field type mapping iterator is NULL.");
d49e1284
JG		 1422 ret = -1;
1423 goto end;
1424 }
1425
74fb0452
JG		 1426 if (iter->index == -1) {
1427 BT_LOGW_STR("Invalid enumeration field type mapping iterator access: position=-1");
1428 ret = -1;
1429 goto end;
1430 }
1431
50842bdc 1432 ret = bt_field_type_enumeration_get_mapping_signed(
d49e1284
JG		 1433 &iter->enumeration_type->parent, iter->index,
1434 mapping_name, range_begin, range_end);
1435end:
1436 return ret;
1437}
1438
50842bdc
PP		 1439int bt_field_type_enumeration_mapping_iterator_get_unsigned(
1440 struct bt_field_type_enumeration_mapping_iterator *iter,
d49e1284
JG		 1441 const char **mapping_name, uint64_t *range_begin,
1442 uint64_t *range_end)
1443{
1444 int ret = 0;
1445
1446 if (!iter) {
4e8304f7 1447 BT_LOGW_STR("Invalid parameter: enumeration field type mapping iterator is NULL.");
d49e1284
JG		 1448 ret = -1;
1449 goto end;
1450 }
1451
74fb0452
JG		 1452 if (iter->index == -1) {
1453 BT_LOGW_STR("Invalid enumeration field type mapping iterator access: position=-1");
1454 ret = -1;
1455 goto end;
1456 }
1457
50842bdc 1458 ret = bt_field_type_enumeration_get_mapping_unsigned(
d49e1284
JG		 1459 &iter->enumeration_type->parent, iter->index,
1460 mapping_name, range_begin, range_end);
1461end:
1462 return ret;
96e8f959
MD		 1463}
1464
50842bdc
PP		 1465int bt_field_type_enumeration_get_mapping_signed(
1466 struct bt_field_type *enum_field_type,
9ac68eb1 1467 uint64_t index, const char **mapping_name, int64_t *range_begin,
96e8f959
MD		 1468 int64_t *range_end)
1469{
d49e1284 1470 int ret = 0;
96e8f959
MD		 1471 struct enumeration_mapping *mapping;
1472
9ac68eb1 1473 if (!enum_field_type) {
4e8304f7 1474 BT_LOGW_STR("Invalid parameter: field type is NULL.");
d49e1284
JG		 1475 ret = -1;
1476 goto end;
96e8f959 1477 }
d49e1284 1478
96e8f959
MD		 1479 mapping = get_enumeration_mapping(enum_field_type, index);
1480 if (!mapping) {
4e8304f7 1481 /* get_enumeration_mapping() reports any error */
d49e1284
JG		 1482 ret = -1;
1483 goto end;
96e8f959 1484 }
d49e1284 1485
96e8f959
MD		 1486 if (mapping_name) {
1487 *mapping_name = g_quark_to_string(mapping->string);
ec159b1e 1488 assert(*mapping_name);
96e8f959 1489 }
d49e1284 1490
96e8f959
MD		 1491 if (range_begin) {
1492 *range_begin = mapping->range_start._signed;
1493 }
d49e1284 1494
96e8f959
MD		 1495 if (range_end) {
1496 *range_end = mapping->range_end._signed;
1497 }
d49e1284
JG		 1498end:
1499 return ret;
96e8f959
MD		 1500}
1501
50842bdc
PP		 1502int bt_field_type_enumeration_get_mapping_unsigned(
1503 struct bt_field_type *enum_field_type,
9ac68eb1 1504 uint64_t index,
96e8f959
MD		 1505 const char **mapping_name, uint64_t *range_begin,
1506 uint64_t *range_end)
1507{
d49e1284 1508 int ret = 0;
96e8f959
MD		 1509 struct enumeration_mapping *mapping;
1510
9ac68eb1 1511 if (!enum_field_type) {
4e8304f7 1512 BT_LOGW_STR("Invalid parameter: field type is NULL.");
d49e1284
JG		 1513 ret = -1;
1514 goto end;
96e8f959 1515 }
d49e1284 1516
96e8f959
MD		 1517 mapping = get_enumeration_mapping(enum_field_type, index);
1518 if (!mapping) {
4e8304f7 1519 /* get_enumeration_mapping() reports any error */
d49e1284
JG		 1520 ret = -1;
1521 goto end;
96e8f959 1522 }
d49e1284 1523
96e8f959
MD		 1524 if (mapping_name) {
1525 *mapping_name = g_quark_to_string(mapping->string);
ec159b1e 1526 assert(*mapping_name);
96e8f959 1527 }
d49e1284 1528
96e8f959
MD		 1529 if (range_begin) {
1530 *range_begin = mapping->range_start._unsigned;
1531 }
d49e1284 1532
96e8f959
MD		 1533 if (range_end) {
1534 *range_end = mapping->range_end._unsigned;
1535 }
d49e1284
JG		 1536end:
1537 return ret;
96e8f959
MD		 1538}
1539
50842bdc
PP		 1540struct bt_field_type *bt_field_type_enumeration_create(
1541 struct bt_field_type *integer_container_type)
273b65be 1542{
50842bdc 1543 struct bt_field_type_enumeration *enumeration = NULL;
273b65be 1544
4e8304f7
PP		 1545 BT_LOGD("Creating enumeration field type object: int-ft-addr=%p",
1546 integer_container_type);
1547
273b65be 1548 if (!integer_container_type) {
4e8304f7 1549 BT_LOGW_STR("Invalid parameter: field type is NULL.");
273b65be
JG		 1550 goto error;
1551 }
1552
50842bdc 1553 if (integer_container_type->id != BT_FIELD_TYPE_ID_INTEGER) {
4e8304f7
PP		 1554 BT_LOGW("Invalid parameter: container field type is not an integer field type: "
1555 "container-ft-addr=%p, container-ft-id=%s",
1556 integer_container_type,
50842bdc 1557 bt_field_type_id_string(integer_container_type->id));
2a610bb7
JG		 1558 goto error;
1559 }
1560
50842bdc 1561 enumeration = g_new0(struct bt_field_type_enumeration, 1);
273b65be 1562 if (!enumeration) {
4e8304f7 1563 BT_LOGE_STR("Failed to allocate one enumeration field type.");
273b65be
JG		 1564 goto error;
1565 }
1566
50842bdc 1567 enumeration->parent.id = BT_FIELD_TYPE_ID_ENUM;
83509119 1568 bt_get(integer_container_type);
273b65be
JG		 1569 enumeration->container = integer_container_type;
1570 enumeration->entries = g_ptr_array_new_with_free_func(
1571 (GDestroyNotify)destroy_enumeration_mapping);
50842bdc 1572 bt_field_type_init(&enumeration->parent, FALSE);
4e8304f7
PP		 1573 BT_LOGD("Created enumeration field type object: addr=%p, "
1574 "int-ft-addr=%p, int-ft-size=%u",
1575 &enumeration->parent, integer_container_type,
50842bdc 1576 bt_field_type_integer_get_size(integer_container_type));
273b65be
JG		 1577 return &enumeration->parent;
1578error:
1579 g_free(enumeration);
1580 return NULL;
1581}
1582
50842bdc
PP		 1583struct bt_field_type *bt_field_type_enumeration_get_container_type(
1584 struct bt_field_type *type)
b92ddaaa 1585{
50842bdc
PP		 1586 struct bt_field_type *container_type = NULL;
1587 struct bt_field_type_enumeration *enumeration_type;
b92ddaaa
JG		 1588
1589 if (!type) {
4e8304f7 1590 BT_LOGW_STR("Invalid parameter: field type is NULL.");
b92ddaaa
JG		 1591 goto end;
1592 }
1593
50842bdc 1594 if (type->id != BT_FIELD_TYPE_ID_ENUM) {
4e8304f7
PP		 1595 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1596 "addr=%p, ft-id=%s", type,
50842bdc 1597 bt_field_type_id_string(type->id));
b92ddaaa
JG		 1598 goto end;
1599 }
1600
1601 enumeration_type = container_of(type,
50842bdc 1602 struct bt_field_type_enumeration, parent);
b92ddaaa 1603 container_type = enumeration_type->container;
83509119 1604 bt_get(container_type);
b92ddaaa
JG		 1605end:
1606 return container_type;
1607}
1608
50842bdc
PP		 1609int bt_field_type_enumeration_add_mapping_signed(
1610 struct bt_field_type *type, const char *string,
273b65be
JG		 1611 int64_t range_start, int64_t range_end)
1612{
1613 int ret = 0;
1614 GQuark mapping_name;
1615 struct enumeration_mapping *mapping;
50842bdc 1616 struct bt_field_type_enumeration *enumeration;
a39fa057 1617 char *escaped_string;
273b65be 1618
4e8304f7
PP		 1619 if (!type) {
1620 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1621 ret = -1;
1622 goto end;
1623 }
1624
1625 if (!string) {
1626 BT_LOGW_STR("Invalid parameter: string is NULL.");
1627 ret = -1;
1628 goto end;
1629 }
1630
1631 if (type->frozen) {
1632 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1633 type);
1634 ret = -1;
1635 goto end;
1636 }
1637
50842bdc 1638 if (type->id != BT_FIELD_TYPE_ID_ENUM) {
4e8304f7
PP		 1639 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1640 "addr=%p, ft-id=%s", type,
50842bdc 1641 bt_field_type_id_string(type->id));
4e8304f7
PP		 1642 ret = -1;
1643 goto end;
1644 }
1645
1646 if (range_end < range_start) {
1647 BT_LOGW("Invalid parameter: range's end is lesser than range's start: "
1648 "addr=%p, range-start=%" PRId64 ", range-end=%" PRId64,
1649 type, range_start, range_end);
273b65be
JG		 1650 ret = -1;
1651 goto end;
1652 }
1653
4e8304f7
PP		 1654 if (strlen(string) == 0) {
1655 BT_LOGW("Invalid parameter: mapping name is an empty string: "
1656 "enum-ft-addr=%p, mapping-name-addr=%p", type,
1657 string);
273b65be
JG		 1658 ret = -1;
1659 goto end;
1660 }
1661
a39fa057
JG		 1662 escaped_string = g_strescape(string, NULL);
1663 if (!escaped_string) {
4e8304f7
PP		 1664 BT_LOGE("Cannot escape mapping name: enum-ft-addr=%p, "
1665 "mapping-name-addr=%p, mapping-name=\"%s\"",
1666 type, string, string);
a39fa057
JG		 1667 ret = -1;
1668 goto end;
1669 }
1670
273b65be
JG		 1671 mapping = g_new(struct enumeration_mapping, 1);
1672 if (!mapping) {
4e8304f7 1673 BT_LOGE_STR("Failed to allocate one enumeration mapping.");
273b65be 1674 ret = -1;
a39fa057 1675 goto error_free;
273b65be 1676 }
96e8f959 1677 mapping_name = g_quark_from_string(escaped_string);
b92ddaaa
JG		 1678 *mapping = (struct enumeration_mapping) {
1679 .range_start._signed = range_start,
96e8f959
MD		 1680 .range_end._signed = range_end,
1681 .string = mapping_name,
1682 };
50842bdc 1683 enumeration = container_of(type, struct bt_field_type_enumeration,
96e8f959 1684 parent);
273b65be 1685 g_ptr_array_add(enumeration->entries, mapping);
b92ddaaa
JG		 1686 g_ptr_array_sort(enumeration->entries,
1687 (GCompareFunc)compare_enumeration_mappings_signed);
dfc1504d
PP		 1688 BT_LOGV("Added mapping to signed enumeration field type: addr=%p, "
1689 "name=\"%s\", range-start=%" PRId64 ", "
1690 "range-end=%" PRId64,
1691 type, string, range_start, range_end);
b92ddaaa
JG		 1692error_free:
1693 free(escaped_string);
1694end:
1695 return ret;
1696}
1697
50842bdc
PP		 1698int bt_field_type_enumeration_add_mapping_unsigned(
1699 struct bt_field_type *type, const char *string,
b92ddaaa
JG		 1700 uint64_t range_start, uint64_t range_end)
1701{
1702 int ret = 0;
1703 GQuark mapping_name;
1704 struct enumeration_mapping *mapping;
50842bdc 1705 struct bt_field_type_enumeration *enumeration;
b92ddaaa
JG		 1706 char *escaped_string;
1707
4e8304f7
PP		 1708 if (!type) {
1709 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1710 ret = -1;
1711 goto end;
1712 }
1713
1714 if (!string) {
1715 BT_LOGW_STR("Invalid parameter: string is NULL.");
1716 ret = -1;
1717 goto end;
1718 }
1719
1720 if (type->frozen) {
1721 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1722 type);
1723 ret = -1;
1724 goto end;
1725 }
1726
50842bdc 1727 if (type->id != BT_FIELD_TYPE_ID_ENUM) {
4e8304f7
PP		 1728 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1729 "addr=%p, ft-id=%s", type,
50842bdc 1730 bt_field_type_id_string(type->id));
4e8304f7
PP		 1731 ret = -1;
1732 goto end;
1733 }
1734
1735 if (range_end < range_start) {
1736 BT_LOGW("Invalid parameter: range's end is lesser than range's start: "
1737 "addr=%p, range-start=%" PRIu64 ", range-end=%" PRIu64,
1738 type, range_start, range_end);
b92ddaaa
JG		 1739 ret = -1;
1740 goto end;
1741 }
1742
4e8304f7
PP		 1743 if (strlen(string) == 0) {
1744 BT_LOGW("Invalid parameter: mapping name is an empty string: "
1745 "enum-ft-addr=%p, mapping-name-addr=%p", type,
1746 string);
b92ddaaa
JG		 1747 ret = -1;
1748 goto end;
1749 }
1750
1751 escaped_string = g_strescape(string, NULL);
1752 if (!escaped_string) {
4e8304f7
PP		 1753 BT_LOGE("Cannot escape mapping name: enum-ft-addr=%p, "
1754 "mapping-name-addr=%p, mapping-name=\"%s\"",
1755 type, string, string);
b92ddaaa
JG		 1756 ret = -1;
1757 goto end;
1758 }
1759
b92ddaaa
JG		 1760 mapping = g_new(struct enumeration_mapping, 1);
1761 if (!mapping) {
4e8304f7 1762 BT_LOGE_STR("Failed to allocate one enumeration mapping.");
b92ddaaa
JG		 1763 ret = -1;
1764 goto error_free;
1765 }
96e8f959 1766 mapping_name = g_quark_from_string(escaped_string);
b92ddaaa
JG		 1767 *mapping = (struct enumeration_mapping) {
1768 .range_start._unsigned = range_start,
96e8f959
MD		 1769 .range_end._unsigned = range_end,
1770 .string = mapping_name,
1771 };
50842bdc 1772 enumeration = container_of(type, struct bt_field_type_enumeration,
96e8f959 1773 parent);
b92ddaaa
JG		 1774 g_ptr_array_add(enumeration->entries, mapping);
1775 g_ptr_array_sort(enumeration->entries,
1776 (GCompareFunc)compare_enumeration_mappings_unsigned);
dfc1504d
PP		 1777 BT_LOGV("Added mapping to unsigned enumeration field type: addr=%p, "
1778 "name=\"%s\", range-start=%" PRIu64 ", "
1779 "range-end=%" PRIu64,
1780 type, string, range_start, range_end);
a39fa057
JG		 1781error_free:
1782 free(escaped_string);
273b65be
JG		 1783end:
1784 return ret;
1785}
1786
50842bdc
PP		 1787int64_t bt_field_type_enumeration_get_mapping_count(
1788 struct bt_field_type *type)
b92ddaaa 1789{
544d0515 1790 int64_t ret = 0;
50842bdc 1791 struct bt_field_type_enumeration *enumeration;
b92ddaaa 1792
4e8304f7
PP		 1793 if (!type) {
1794 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1795 ret = (int64_t) -1;
1796 goto end;
1797 }
1798
50842bdc 1799 if (type->id != BT_FIELD_TYPE_ID_ENUM) {
4e8304f7
PP		 1800 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
1801 "addr=%p, ft-id=%s", type,
50842bdc 1802 bt_field_type_id_string(type->id));
9ac68eb1 1803 ret = (int64_t) -1;
b92ddaaa
JG		 1804 goto end;
1805 }
1806
50842bdc 1807 enumeration = container_of(type, struct bt_field_type_enumeration,
b92ddaaa 1808 parent);
544d0515 1809 ret = (int64_t) enumeration->entries->len;
b92ddaaa
JG		 1810end:
1811 return ret;
1812}
1813
50842bdc 1814struct bt_field_type *bt_field_type_floating_point_create(void)
273b65be 1815{
50842bdc
PP		 1816 struct bt_field_type_floating_point *floating_point =
1817 g_new0(struct bt_field_type_floating_point, 1);
273b65be 1818
4e8304f7
PP		 1819 BT_LOGD_STR("Creating floating point number field type object.");
1820
273b65be 1821 if (!floating_point) {
4e8304f7 1822 BT_LOGE_STR("Failed to allocate one floating point number field type.");
273b65be
JG		 1823 goto end;
1824 }
1825
50842bdc 1826 floating_point->parent.id = BT_FIELD_TYPE_ID_FLOAT;
dc3fffef
PP		 1827 floating_point->exp_dig = sizeof(float) * CHAR_BIT - FLT_MANT_DIG;
1828 floating_point->mant_dig = FLT_MANT_DIG;
50842bdc 1829 bt_field_type_init(&floating_point->parent, TRUE);
4e8304f7
PP		 1830 BT_LOGD("Created floating point number field type object: addr=%p, "
1831 "exp-size=%u, mant-size=%u", &floating_point->parent,
1832 floating_point->exp_dig, floating_point->mant_dig);
273b65be
JG		 1833end:
1834 return floating_point ? &floating_point->parent : NULL;
1835}
1836
50842bdc
PP		 1837int bt_field_type_floating_point_get_exponent_digits(
1838 struct bt_field_type *type)
b92ddaaa
JG		 1839{
1840 int ret = 0;
50842bdc 1841 struct bt_field_type_floating_point *floating_point;
b92ddaaa 1842
4e8304f7
PP		 1843 if (!type) {
1844 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1845 ret = -1;
1846 goto end;
1847 }
1848
50842bdc 1849 if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
4e8304f7
PP		 1850 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1851 "addr=%p, ft-id=%s", type,
50842bdc 1852 bt_field_type_id_string(type->id));
b92ddaaa
JG		 1853 ret = -1;
1854 goto end;
1855 }
1856
1857 floating_point = container_of(type,
50842bdc 1858 struct bt_field_type_floating_point, parent);
dc3fffef 1859 ret = (int) floating_point->exp_dig;
b92ddaaa
JG		 1860end:
1861 return ret;
1862}
1863
50842bdc
PP		 1864int bt_field_type_floating_point_set_exponent_digits(
1865 struct bt_field_type *type,
273b65be
JG		 1866 unsigned int exponent_digits)
1867{
1868 int ret = 0;
50842bdc 1869 struct bt_field_type_floating_point *floating_point;
273b65be 1870
4e8304f7
PP		 1871 if (!type) {
1872 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1873 ret = -1;
1874 goto end;
1875 }
1876
1877 if (type->frozen) {
1878 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1879 type);
1880 ret = -1;
1881 goto end;
1882 }
1883
50842bdc 1884 if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
4e8304f7
PP		 1885 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1886 "addr=%p, ft-id=%s", type,
50842bdc 1887 bt_field_type_id_string(type->id));
273b65be
JG		 1888 ret = -1;
1889 goto end;
1890 }
1891
1892 floating_point = container_of(type,
50842bdc 1893 struct bt_field_type_floating_point, parent);
273b65be
JG		 1894 if ((exponent_digits != sizeof(float) * CHAR_BIT - FLT_MANT_DIG) &&
1895 (exponent_digits != sizeof(double) * CHAR_BIT - DBL_MANT_DIG) &&
1896 (exponent_digits !=
1897 sizeof(long double) * CHAR_BIT - LDBL_MANT_DIG)) {
4e8304f7
PP		 1898 BT_LOGW("Invalid parameter: invalid exponent size: "
1899 "addr=%p, exp-size=%u", type, exponent_digits);
273b65be
JG		 1900 ret = -1;
1901 goto end;
1902 }
1903
dc3fffef 1904 floating_point->exp_dig = exponent_digits;
dfc1504d
PP		 1905 BT_LOGV("Set floating point number field type's exponent size: addr=%p, "
1906 "exp-size=%u", type, exponent_digits);
273b65be
JG		 1907end:
1908 return ret;
1909}
1910
50842bdc
PP		 1911int bt_field_type_floating_point_get_mantissa_digits(
1912 struct bt_field_type *type)
b92ddaaa
JG		 1913{
1914 int ret = 0;
50842bdc 1915 struct bt_field_type_floating_point *floating_point;
b92ddaaa 1916
4e8304f7
PP		 1917 if (!type) {
1918 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1919 ret = -1;
1920 goto end;
1921 }
1922
50842bdc 1923 if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
4e8304f7
PP		 1924 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1925 "addr=%p, ft-id=%s", type,
50842bdc 1926 bt_field_type_id_string(type->id));
b92ddaaa
JG		 1927 ret = -1;
1928 goto end;
1929 }
1930
1931 floating_point = container_of(type,
50842bdc 1932 struct bt_field_type_floating_point, parent);
dc3fffef 1933 ret = (int) floating_point->mant_dig;
b92ddaaa
JG		 1934end:
1935 return ret;
1936}
1937
50842bdc
PP		 1938int bt_field_type_floating_point_set_mantissa_digits(
1939 struct bt_field_type *type,
273b65be
JG		 1940 unsigned int mantissa_digits)
1941{
1942 int ret = 0;
50842bdc 1943 struct bt_field_type_floating_point *floating_point;
273b65be 1944
4e8304f7
PP		 1945 if (!type) {
1946 BT_LOGW_STR("Invalid parameter: field type is NULL.");
1947 ret = -1;
1948 goto end;
1949 }
1950
1951 if (type->frozen) {
1952 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
1953 type);
1954 ret = -1;
1955 goto end;
1956 }
1957
50842bdc 1958 if (type->id != BT_FIELD_TYPE_ID_FLOAT) {
4e8304f7
PP		 1959 BT_LOGW("Invalid parameter: field type is not a floating point number field type: "
1960 "addr=%p, ft-id=%s", type,
50842bdc 1961 bt_field_type_id_string(type->id));
273b65be
JG		 1962 ret = -1;
1963 goto end;
1964 }
1965
1966 floating_point = container_of(type,
50842bdc 1967 struct bt_field_type_floating_point, parent);
273b65be
JG		 1968
1969 if ((mantissa_digits != FLT_MANT_DIG) &&
1970 (mantissa_digits != DBL_MANT_DIG) &&
1971 (mantissa_digits != LDBL_MANT_DIG)) {
4e8304f7
PP		 1972 BT_LOGW("Invalid parameter: invalid mantissa size: "
1973 "addr=%p, mant-size=%u", type, mantissa_digits);
273b65be
JG		 1974 ret = -1;
1975 goto end;
1976 }
1977
dc3fffef 1978 floating_point->mant_dig = mantissa_digits;
dfc1504d
PP		 1979 BT_LOGV("Set floating point number field type's mantissa size: addr=%p, "
1980 "mant-size=%u", type, mantissa_digits);
273b65be
JG		 1981end:
1982 return ret;
1983}
1984
50842bdc 1985struct bt_field_type *bt_field_type_structure_create(void)
273b65be 1986{
50842bdc
PP		 1987 struct bt_field_type_structure *structure =
1988 g_new0(struct bt_field_type_structure, 1);
273b65be 1989
4e8304f7
PP		 1990 BT_LOGD_STR("Creating structure field type object.");
1991
273b65be 1992 if (!structure) {
4e8304f7 1993 BT_LOGE_STR("Failed to allocate one structure field type.");
273b65be
JG		 1994 goto error;
1995 }
1996
50842bdc 1997 structure->parent.id = BT_FIELD_TYPE_ID_STRUCT;
273b65be
JG		 1998 structure->fields = g_ptr_array_new_with_free_func(
1999 (GDestroyNotify)destroy_structure_field);
2000 structure->field_name_to_index = g_hash_table_new(NULL, NULL);
50842bdc 2001 bt_field_type_init(&structure->parent, TRUE);
4e8304f7
PP		 2002 BT_LOGD("Created structure field type object: addr=%p",
2003 &structure->parent);
273b65be
JG		 2004 return &structure->parent;
2005error:
2006 return NULL;
2007}
2008
50842bdc
PP		 2009int bt_field_type_structure_add_field(struct bt_field_type *type,
2010 struct bt_field_type *field_type,
273b65be
JG		 2011 const char *field_name)
2012{
2013 int ret = 0;
50842bdc 2014 struct bt_field_type_structure *structure;
273b65be 2015
73892edc
PP		 2016 /*
2017 * TODO: check that `field_type` does not contain `type`,
2018 * recursively.
2019 */
4e8304f7
PP		 2020 if (!type) {
2021 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2022 ret = -1;
2023 goto end;
2024 }
2025
2026 if (!field_name) {
2027 BT_LOGW_STR("Invalid parameter: field name is NULL.");
2028 ret = -1;
2029 goto end;
2030 }
2031
2032 if (type->frozen) {
2033 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
2034 type);
2035 ret = -1;
2036 goto end;
2037 }
2038
50842bdc 2039 if (type->id != BT_FIELD_TYPE_ID_STRUCT) {
4e8304f7
PP		 2040 BT_LOGW("Invalid parameter: field type is not a structure field type: "
2041 "addr=%p, ft-id=%s", type,
50842bdc 2042 bt_field_type_id_string(type->id));
4e8304f7
PP		 2043 ret = -1;
2044 goto end;
2045 }
2046
2047 if (type == field_type) {
2048 BT_LOGW("Invalid parameter: structure field type and field type to add are the same: "
2049 "addr=%p", type);
e6235f1f 2050 ret = -1;
273b65be
JG		 2051 goto end;
2052 }
2053
2054 structure = container_of(type,
50842bdc 2055 struct bt_field_type_structure, parent);
273b65be 2056 if (add_structure_field(structure->fields,
4e8304f7
PP		 2057 structure->field_name_to_index, field_type, field_name)) {
2058 BT_LOGW("Cannot add field to structure field type: "
2059 "struct-ft-addr=%p, field-ft-addr=%p, field-name=\"%s\"",
2060 type, field_type, field_name);
273b65be
JG		 2061 ret = -1;
2062 goto end;
2063 }
dfc1504d
PP		 2064
2065 BT_LOGV("Added structure field type field: struct-ft-addr=%p, "
2066 "field-ft-addr=%p, field-name=\"%s\"", type,
2067 field_type, field_name);
b92ddaaa
JG		 2068end:
2069 return ret;
2070}
2071
50842bdc
PP		 2072int64_t bt_field_type_structure_get_field_count(
2073 struct bt_field_type *type)
b92ddaaa 2074{
544d0515 2075 int64_t ret = 0;
50842bdc 2076 struct bt_field_type_structure *structure;
b92ddaaa 2077
4e8304f7
PP		 2078 if (!type) {
2079 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2080 ret = (int64_t) -1;
2081 goto end;
2082 }
2083
50842bdc 2084 if (type->id != BT_FIELD_TYPE_ID_STRUCT) {
4e8304f7
PP		 2085 BT_LOGW("Invalid parameter: field type is not a structure field type: "
2086 "addr=%p, ft-id=%s", type,
50842bdc 2087 bt_field_type_id_string(type->id));
9ac68eb1 2088 ret = (int64_t) -1;
b92ddaaa
JG		 2089 goto end;
2090 }
2091
50842bdc 2092 structure = container_of(type, struct bt_field_type_structure,
b92ddaaa 2093 parent);
544d0515 2094 ret = (int64_t) structure->fields->len;
b92ddaaa
JG		 2095end:
2096 return ret;
2097}
2098
50842bdc
PP		 2099int bt_field_type_structure_get_field_by_index(
2100 struct bt_field_type *type,
2101 const char **field_name, struct bt_field_type **field_type,
9ac68eb1 2102 uint64_t index)
b92ddaaa 2103{
50842bdc 2104 struct bt_field_type_structure *structure;
b92ddaaa
JG		 2105 struct structure_field *field;
2106 int ret = 0;
2107
4e8304f7
PP		 2108 if (!type) {
2109 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2110 ret = -1;
2111 goto end;
2112 }
2113
50842bdc 2114 if (type->id != BT_FIELD_TYPE_ID_STRUCT) {
4e8304f7
PP		 2115 BT_LOGW("Invalid parameter: field type is not a structure field type: "
2116 "addr=%p, ft-id=%s", type,
50842bdc 2117 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2118 ret = -1;
2119 goto end;
2120 }
2121
50842bdc 2122 structure = container_of(type, struct bt_field_type_structure,
b92ddaaa
JG		 2123 parent);
2124 if (index >= structure->fields->len) {
4e8304f7
PP		 2125 BT_LOGW("Invalid parameter: index is out of bounds: "
2126 "addr=%p, index=%" PRIu64 ", count=%u",
2127 type, index, structure->fields->len);
b92ddaaa
JG		 2128 ret = -1;
2129 goto end;
2130 }
2131
2132 field = g_ptr_array_index(structure->fields, index);
f9b799fc
JG		 2133 if (field_type) {
2134 *field_type = field->type;
83509119 2135 bt_get(field->type);
f9b799fc
JG		 2136 }
2137 if (field_name) {
2138 *field_name = g_quark_to_string(field->name);
ec159b1e 2139 assert(*field_name);
f9b799fc 2140 }
b92ddaaa
JG		 2141end:
2142 return ret;
2143}
2144
50842bdc
PP		 2145struct bt_field_type *bt_field_type_structure_get_field_type_by_name(
2146 struct bt_field_type *type,
b92ddaaa
JG		 2147 const char *name)
2148{
2149 size_t index;
2150 GQuark name_quark;
2151 struct structure_field *field;
50842bdc
PP		 2152 struct bt_field_type_structure *structure;
2153 struct bt_field_type *field_type = NULL;
b92ddaaa 2154
4e8304f7
PP		 2155 if (!type) {
2156 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2157 goto end;
2158 }
2159
2160 if (!name) {
2161 BT_LOGW_STR("Invalid parameter: name is NULL.");
b92ddaaa
JG		 2162 goto end;
2163 }
2164
2165 name_quark = g_quark_try_string(name);
2166 if (!name_quark) {
6fa8d37b
PP		 2167 BT_LOGV("No such structure field type field name: "
2168 "ft-addr=%p, field-name=\"%s\"",
2169 type, name);
b92ddaaa
JG		 2170 goto end;
2171 }
2172
50842bdc 2173 structure = container_of(type, struct bt_field_type_structure,
b92ddaaa
JG		 2174 parent);
2175 if (!g_hash_table_lookup_extended(structure->field_name_to_index,
6fa8d37b
PP		 2176 GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
2177 BT_LOGV("No such structure field type field name: "
2178 "ft-addr=%p, field-name=\"%s\"",
2179 type, name);
b92ddaaa 2180 goto end;
273b65be 2181 }
b92ddaaa
JG		 2182
2183 field = structure->fields->pdata[index];
2184 field_type = field->type;
83509119 2185 bt_get(field_type);
273b65be 2186end:
b92ddaaa 2187 return field_type;
273b65be
JG		 2188}
2189
50842bdc
PP		 2190struct bt_field_type *bt_field_type_variant_create(
2191 struct bt_field_type *enum_tag, const char *tag_name)
273b65be 2192{
50842bdc 2193 struct bt_field_type_variant *variant = NULL;
273b65be 2194
4e8304f7
PP		 2195 BT_LOGD("Creating variant field type object: "
2196 "tag-ft-addr=%p, tag-field-name=\"%s\"",
2197 enum_tag, tag_name);
2198
f4cc9a21 2199 if (tag_name && !bt_identifier_is_valid(tag_name)) {
4e8304f7
PP		 2200 BT_LOGW("Invalid parameter: tag field name is not a valid CTF identifier: "
2201 "tag-ft-addr=%p, tag-field-name=\"%s\"",
2202 enum_tag, tag_name);
273b65be
JG		 2203 goto error;
2204 }
2205
50842bdc 2206 variant = g_new0(struct bt_field_type_variant, 1);
273b65be 2207 if (!variant) {
4e8304f7 2208 BT_LOGE_STR("Failed to allocate one variant field type.");
273b65be
JG		 2209 goto error;
2210 }
2211
50842bdc 2212 variant->parent.id = BT_FIELD_TYPE_ID_VARIANT;
273b65be 2213 variant->tag_name = g_string_new(tag_name);
273b65be
JG		 2214 variant->field_name_to_index = g_hash_table_new(NULL, NULL);
2215 variant->fields = g_ptr_array_new_with_free_func(
83509119 2216 (GDestroyNotify) destroy_structure_field);
6964b7fd 2217 if (enum_tag) {
83509119 2218 bt_get(enum_tag);
6964b7fd 2219 variant->tag = container_of(enum_tag,
50842bdc 2220 struct bt_field_type_enumeration, parent);
6964b7fd
JG		 2221 }
2222
50842bdc 2223 bt_field_type_init(&variant->parent, TRUE);
46caf2cb 2224 /* A variant's alignment is undefined */
dc3fffef 2225 variant->parent.alignment = 0;
4e8304f7
PP		 2226 BT_LOGD("Created variant field type object: addr=%p, "
2227 "tag-ft-addr=%p, tag-field-name=\"%s\"",
2228 &variant->parent, enum_tag, tag_name);
273b65be
JG		 2229 return &variant->parent;
2230error:
2231 return NULL;
2232}
2233
50842bdc
PP		 2234struct bt_field_type *bt_field_type_variant_get_tag_type(
2235 struct bt_field_type *type)
b92ddaaa 2236{
50842bdc
PP		 2237 struct bt_field_type_variant *variant;
2238 struct bt_field_type *tag_type = NULL;
b92ddaaa 2239
4e8304f7
PP		 2240 if (!type) {
2241 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2242 goto end;
2243 }
2244
50842bdc 2245 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2246 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2247 "addr=%p, ft-id=%s", type,
50842bdc 2248 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2249 goto end;
2250 }
2251
50842bdc 2252 variant = container_of(type, struct bt_field_type_variant, parent);
6964b7fd 2253 if (!variant->tag) {
4e8304f7
PP		 2254 BT_LOGV("Variant field type has no tag field type: "
2255 "addr=%p", type);
6964b7fd
JG		 2256 goto end;
2257 }
2258
b92ddaaa 2259 tag_type = &variant->tag->parent;
83509119 2260 bt_get(tag_type);
b92ddaaa
JG		 2261end:
2262 return tag_type;
2263}
2264
50842bdc
PP		 2265const char *bt_field_type_variant_get_tag_name(
2266 struct bt_field_type *type)
b92ddaaa 2267{
50842bdc 2268 struct bt_field_type_variant *variant;
b92ddaaa
JG		 2269 const char *tag_name = NULL;
2270
4e8304f7
PP		 2271 if (!type) {
2272 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2273 goto end;
2274 }
2275
50842bdc 2276 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2277 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2278 "addr=%p, ft-id=%s", type,
50842bdc 2279 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2280 goto end;
2281 }
2282
50842bdc 2283 variant = container_of(type, struct bt_field_type_variant, parent);
6964b7fd 2284 if (variant->tag_name->len == 0) {
4e8304f7
PP		 2285 BT_LOGV("Variant field type has no tag field name: "
2286 "addr=%p", type);
6964b7fd
JG		 2287 goto end;
2288 }
2289
b92ddaaa
JG		 2290 tag_name = variant->tag_name->str;
2291end:
2292 return tag_name;
2293}
2294
50842bdc
PP		 2295int bt_field_type_variant_set_tag_name(
2296 struct bt_field_type *type, const char *name)
d9b1ab6d
JG		 2297{
2298 int ret = 0;
50842bdc 2299 struct bt_field_type_variant *variant;
d9b1ab6d 2300
4e8304f7
PP		 2301 if (!type) {
2302 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2303 ret = -1;
2304 goto end;
2305 }
2306
2307 if (type->frozen) {
2308 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
2309 type);
2310 ret = -1;
2311 goto end;
2312 }
2313
50842bdc 2314 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2315 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2316 "addr=%p, ft-id=%s", type,
50842bdc 2317 bt_field_type_id_string(type->id));
4e8304f7
PP		 2318 ret = -1;
2319 goto end;
2320 }
2321
f4cc9a21 2322 if (!bt_identifier_is_valid(name)) {
4e8304f7
PP		 2323 BT_LOGW("Invalid parameter: tag field name is not a valid CTF identifier: "
2324 "variant-ft-addr=%p, tag-field-name=\"%s\"",
2325 type, name);
d9b1ab6d
JG		 2326 ret = -1;
2327 goto end;
2328 }
2329
50842bdc 2330 variant = container_of(type, struct bt_field_type_variant, parent);
d9b1ab6d 2331 g_string_assign(variant->tag_name, name);
dfc1504d
PP		 2332 BT_LOGV("Set variant field type's tag field name: addr=%p, "
2333 "tag-field-name=\"%s\"", type, name);
d9b1ab6d
JG		 2334end:
2335 return ret;
2336}
2337
50842bdc
PP		 2338int bt_field_type_variant_add_field(struct bt_field_type *type,
2339 struct bt_field_type *field_type,
4e8304f7
PP		 2340 const char *field_name)
2341{
2342 size_t i;
2343 int ret = 0;
50842bdc 2344 struct bt_field_type_variant *variant;
4e8304f7
PP		 2345 GQuark field_name_quark = g_quark_from_string(field_name);
2346
2347 /*
2348 * TODO: check that `field_type` does not contain `type`,
2349 * recursively.
2350 */
2351 if (!type) {
2352 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2353 ret = -1;
2354 goto end;
2355 }
2356
2357 if (type->frozen) {
2358 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
2359 type);
2360 ret = -1;
2361 goto end;
2362 }
2363
50842bdc 2364 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2365 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2366 "addr=%p, ft-id=%s", type,
50842bdc 2367 bt_field_type_id_string(type->id));
4e8304f7
PP		 2368 ret = -1;
2369 goto end;
2370 }
273b65be 2371
4e8304f7
PP		 2372 if (type == field_type) {
2373 BT_LOGW("Invalid parameter: variant field type and field type to add are the same: "
2374 "addr=%p", type);
273b65be
JG		 2375 ret = -1;
2376 goto end;
2377 }
2378
50842bdc 2379 variant = container_of(type, struct bt_field_type_variant, parent);
273b65be 2380
6964b7fd
JG		 2381 /* The user has explicitly provided a tag; validate against it. */
2382 if (variant->tag) {
2383 int name_found = 0;
2384
2385 /* Make sure this name is present in the enum tag */
2386 for (i = 0; i < variant->tag->entries->len; i++) {
2387 struct enumeration_mapping *mapping =
2388 g_ptr_array_index(variant->tag->entries, i);
2389
2390 if (mapping->string == field_name_quark) {
2391 name_found = 1;
2392 break;
2393 }
2394 }
2395
2396 if (!name_found) {
2397 /* Validation failed */
4e8304f7
PP		 2398 BT_LOGW("Invalid parameter: field name does not name a tag field type's mapping: "
2399 "variant-ft-addr=%p, tag-ft-addr=%p, "
2400 "tag-field-name=\"%s\""
2401 "field-ft-addr=%p, field-name=\"%s\"",
2402 type, variant->tag, variant->tag_name->str,
2403 field_type, field_name);
6964b7fd
JG		 2404 ret = -1;
2405 goto end;
273b65be
JG		 2406 }
2407 }
2408
6964b7fd 2409 if (add_structure_field(variant->fields, variant->field_name_to_index,
4e8304f7
PP		 2410 field_type, field_name)) {
2411 BT_LOGW("Cannot add field to variant field type: "
2412 "variant-ft-addr=%p, field-ft-addr=%p, field-name=\"%s\"",
2413 type, field_type, field_name);
273b65be
JG		 2414 ret = -1;
2415 goto end;
2416 }
dfc1504d
PP		 2417
2418 BT_LOGV("Added variant field type field: variant-ft-addr=%p, "
2419 "field-ft-addr=%p, field-name=\"%s\"", type,
2420 field_type, field_name);
2421
273b65be
JG		 2422end:
2423 return ret;
2424}
2425
50842bdc
PP		 2426struct bt_field_type *bt_field_type_variant_get_field_type_by_name(
2427 struct bt_field_type *type,
b92ddaaa
JG		 2428 const char *field_name)
2429{
2430 size_t index;
2431 GQuark name_quark;
2432 struct structure_field *field;
50842bdc
PP		 2433 struct bt_field_type_variant *variant;
2434 struct bt_field_type *field_type = NULL;
b92ddaaa 2435
4e8304f7
PP		 2436 if (!type) {
2437 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2438 goto end;
2439 }
2440
2441 if (!field_name) {
2442 BT_LOGW_STR("Invalid parameter: field name is NULL.");
b92ddaaa
JG		 2443 goto end;
2444 }
2445
2446 name_quark = g_quark_try_string(field_name);
2447 if (!name_quark) {
6fa8d37b
PP		 2448 BT_LOGV("No such variant field type field name: "
2449 "ft-addr=%p, field-name=\"%s\"",
2450 type, field_name);
b92ddaaa
JG		 2451 goto end;
2452 }
2453
50842bdc 2454 variant = container_of(type, struct bt_field_type_variant, parent);
b92ddaaa 2455 if (!g_hash_table_lookup_extended(variant->field_name_to_index,
6fa8d37b
PP		 2456 GUINT_TO_POINTER(name_quark), NULL, (gpointer *)&index)) {
2457 BT_LOGV("No such variant field type field name: "
2458 "ft-addr=%p, field-name=\"%s\"",
2459 type, field_name);
b92ddaaa
JG		 2460 goto end;
2461 }
2462
2463 field = g_ptr_array_index(variant->fields, index);
2464 field_type = field->type;
83509119 2465 bt_get(field_type);
b92ddaaa
JG		 2466end:
2467 return field_type;
2468}
2469
50842bdc
PP		 2470struct bt_field_type *bt_field_type_variant_get_field_type_from_tag(
2471 struct bt_field_type *type,
2472 struct bt_field *tag)
b92ddaaa 2473{
e0f15669 2474 int ret;
b92ddaaa 2475 const char *enum_value;
50842bdc
PP		 2476 struct bt_field_type *field_type = NULL;
2477 struct bt_field_type_enumeration_mapping_iterator *iter = NULL;
b92ddaaa 2478
4e8304f7
PP		 2479 if (!type) {
2480 BT_LOGW_STR("Invalid parameter: variant field type is NULL.");
2481 goto end;
2482 }
2483
2484 if (!tag) {
2485 BT_LOGW_STR("Invalid parameter: tag field is NULL.");
2486 goto end;
2487 }
2488
50842bdc 2489 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2490 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2491 "addr=%p, ft-id=%s", type,
50842bdc 2492 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2493 goto end;
2494 }
2495
50842bdc
PP		 2496 iter = bt_field_enumeration_get_mappings(tag);
2497 ret = bt_field_type_enumeration_mapping_iterator_next(iter);
74fb0452 2498 if (!iter || ret) {
4e8304f7
PP		 2499 BT_LOGE("Cannot get enumeration field type mapping iterator from enumeration field: "
2500 "enum-field-addr=%p", tag);
e0f15669
JG		 2501 goto end;
2502 }
2503
50842bdc 2504 ret = bt_field_type_enumeration_mapping_iterator_get_signed(iter,
5c3f3b7e 2505 &enum_value, NULL, NULL);
e0f15669 2506 if (ret) {
4e8304f7
PP		 2507 BT_LOGW("Cannot get enumeration field type mapping iterator's current mapping: "
2508 "iter-addr=%p", iter);
b92ddaaa
JG		 2509 goto end;
2510 }
2511
50842bdc 2512 field_type = bt_field_type_variant_get_field_type_by_name(
b92ddaaa
JG		 2513 type, enum_value);
2514end:
e0f15669 2515 bt_put(iter);
b92ddaaa
JG		 2516 return field_type;
2517}
2518
50842bdc 2519int64_t bt_field_type_variant_get_field_count(struct bt_field_type *type)
b92ddaaa 2520{
544d0515 2521 int64_t ret = 0;
50842bdc 2522 struct bt_field_type_variant *variant;
b92ddaaa 2523
4e8304f7
PP		 2524 if (!type) {
2525 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2526 ret = (int64_t) -1;
2527 goto end;
2528 }
2529
50842bdc 2530 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2531 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2532 "addr=%p, ft-id=%s", type,
50842bdc 2533 bt_field_type_id_string(type->id));
9ac68eb1 2534 ret = (int64_t) -1;
b92ddaaa
JG		 2535 goto end;
2536 }
2537
50842bdc 2538 variant = container_of(type, struct bt_field_type_variant,
b92ddaaa 2539 parent);
544d0515 2540 ret = (int64_t) variant->fields->len;
b92ddaaa
JG		 2541end:
2542 return ret;
2543
2544}
2545
50842bdc
PP		 2546int bt_field_type_variant_get_field_by_index(struct bt_field_type *type,
2547 const char **field_name, struct bt_field_type **field_type,
9ac68eb1 2548 uint64_t index)
b92ddaaa 2549{
50842bdc 2550 struct bt_field_type_variant *variant;
b92ddaaa
JG		 2551 struct structure_field *field;
2552 int ret = 0;
2553
4e8304f7
PP		 2554 if (!type) {
2555 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2556 ret = -1;
2557 goto end;
2558 }
2559
50842bdc 2560 if (type->id != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 2561 BT_LOGW("Invalid parameter: field type is not a variant field type: "
2562 "addr=%p, ft-id=%s", type,
50842bdc 2563 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2564 ret = -1;
2565 goto end;
2566 }
2567
50842bdc 2568 variant = container_of(type, struct bt_field_type_variant,
b92ddaaa
JG		 2569 parent);
2570 if (index >= variant->fields->len) {
4e8304f7
PP		 2571 BT_LOGW("Invalid parameter: index is out of bounds: "
2572 "addr=%p, index=%" PRIu64 ", count=%u",
2573 type, index, variant->fields->len);
b92ddaaa
JG		 2574 ret = -1;
2575 goto end;
2576 }
2577
2578 field = g_ptr_array_index(variant->fields, index);
647f3b93
JG		 2579 if (field_type) {
2580 *field_type = field->type;
83509119 2581 bt_get(field->type);
647f3b93
JG		 2582 }
2583 if (field_name) {
2584 *field_name = g_quark_to_string(field->name);
ec159b1e 2585 assert(*field_name);
647f3b93 2586 }
b92ddaaa
JG		 2587end:
2588 return ret;
2589}
2590
50842bdc
PP		 2591struct bt_field_type *bt_field_type_array_create(
2592 struct bt_field_type *element_type,
273b65be
JG		 2593 unsigned int length)
2594{
50842bdc 2595 struct bt_field_type_array *array = NULL;
273b65be 2596
4e8304f7
PP		 2597 BT_LOGD("Creating array field type object: element-ft-addr=%p, "
2598 "length=%u", element_type, length);
2599
2600 if (!element_type) {
2601 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2602 goto error;
2603 }
2604
2605 if (length == 0) {
2606 BT_LOGW_STR("Invalid parameter: length is zero.");
273b65be
JG		 2607 goto error;
2608 }
2609
50842bdc 2610 array = g_new0(struct bt_field_type_array, 1);
273b65be 2611 if (!array) {
4e8304f7 2612 BT_LOGE_STR("Failed to allocate one array field type.");
273b65be
JG		 2613 goto error;
2614 }
2615
50842bdc 2616 array->parent.id = BT_FIELD_TYPE_ID_ARRAY;
83509119 2617 bt_get(element_type);
273b65be
JG		 2618 array->element_type = element_type;
2619 array->length = length;
50842bdc 2620 bt_field_type_init(&array->parent, FALSE);
4e8304f7
PP		 2621 BT_LOGD("Created array field type object: addr=%p, "
2622 "element-ft-addr=%p, length=%u",
2623 &array->parent, element_type, length);
273b65be
JG		 2624 return &array->parent;
2625error:
2626 return NULL;
2627}
2628
50842bdc
PP		 2629struct bt_field_type *bt_field_type_array_get_element_type(
2630 struct bt_field_type *type)
b92ddaaa 2631{
50842bdc
PP		 2632 struct bt_field_type *ret = NULL;
2633 struct bt_field_type_array *array;
b92ddaaa 2634
4e8304f7
PP		 2635 if (!type) {
2636 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2637 goto end;
2638 }
2639
50842bdc 2640 if (type->id != BT_FIELD_TYPE_ID_ARRAY) {
4e8304f7
PP		 2641 BT_LOGW("Invalid parameter: field type is not an array field type: "
2642 "addr=%p, ft-id=%s", type,
50842bdc 2643 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2644 goto end;
2645 }
2646
50842bdc 2647 array = container_of(type, struct bt_field_type_array, parent);
b92ddaaa 2648 ret = array->element_type;
83509119 2649 bt_get(ret);
b92ddaaa
JG		 2650end:
2651 return ret;
2652}
2653
626e93aa 2654BT_HIDDEN
50842bdc
PP		 2655int bt_field_type_array_set_element_type(struct bt_field_type *type,
2656 struct bt_field_type *element_type)
626e93aa
PP		 2657{
2658 int ret = 0;
50842bdc 2659 struct bt_field_type_array *array;
626e93aa 2660
4e8304f7
PP		 2661 if (!type) {
2662 BT_LOGW_STR("Invalid parameter: array field type is NULL.");
2663 ret = -1;
2664 goto end;
2665 }
2666
2667 if (!element_type) {
2668 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2669 ret = -1;
2670 goto end;
2671 }
2672
50842bdc 2673 if (type->id != BT_FIELD_TYPE_ID_ARRAY) {
4e8304f7
PP		 2674 BT_LOGW("Invalid parameter: field type is not an array field type: "
2675 "addr=%p, ft-id=%s", type,
50842bdc 2676 bt_field_type_id_string(type->id));
626e93aa
PP		 2677 ret = -1;
2678 goto end;
2679 }
2680
50842bdc 2681 array = container_of(type, struct bt_field_type_array, parent);
626e93aa
PP		 2682
2683 if (array->element_type) {
2684 BT_PUT(array->element_type);
2685 }
2686
2687 array->element_type = element_type;
2688 bt_get(array->element_type);
dfc1504d
PP		 2689 BT_LOGV("Set array field type's element field type: array-ft-addr=%p, "
2690 "element-ft-addr=%p", type, element_type);
626e93aa
PP		 2691
2692end:
2693 return ret;
2694}
2695
50842bdc 2696int64_t bt_field_type_array_get_length(struct bt_field_type *type)
b92ddaaa
JG		 2697{
2698 int64_t ret;
50842bdc 2699 struct bt_field_type_array *array;
b92ddaaa 2700
4e8304f7
PP		 2701 if (!type) {
2702 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2703 ret = (int64_t) -1;
2704 goto end;
2705 }
2706
50842bdc 2707 if (type->id != BT_FIELD_TYPE_ID_ARRAY) {
4e8304f7
PP		 2708 BT_LOGW("Invalid parameter: field type is not an array field type: "
2709 "addr=%p, ft-id=%s", type,
50842bdc 2710 bt_field_type_id_string(type->id));
9ac68eb1 2711 ret = (int64_t) -1;
b92ddaaa
JG		 2712 goto end;
2713 }
2714
50842bdc 2715 array = container_of(type, struct bt_field_type_array, parent);
b92ddaaa
JG		 2716 ret = (int64_t) array->length;
2717end:
2718 return ret;
2719}
2720
50842bdc
PP		 2721struct bt_field_type *bt_field_type_sequence_create(
2722 struct bt_field_type *element_type,
273b65be
JG		 2723 const char *length_field_name)
2724{
50842bdc 2725 struct bt_field_type_sequence *sequence = NULL;
273b65be 2726
4e8304f7
PP		 2727 BT_LOGD("Creating sequence field type object: element-ft-addr=%p, "
2728 "length-field-name=\"%s\"", element_type, length_field_name);
2729
2730 if (!element_type) {
2731 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2732 goto error;
2733 }
2734
f4cc9a21 2735 if (!bt_identifier_is_valid(length_field_name)) {
4e8304f7
PP		 2736 BT_LOGW("Invalid parameter: length field name is not a valid CTF identifier: "
2737 "length-field-name=\"%s\"", length_field_name);
273b65be
JG		 2738 goto error;
2739 }
2740
50842bdc 2741 sequence = g_new0(struct bt_field_type_sequence, 1);
273b65be 2742 if (!sequence) {
4e8304f7 2743 BT_LOGE_STR("Failed to allocate one sequence field type.");
273b65be
JG		 2744 goto error;
2745 }
2746
50842bdc 2747 sequence->parent.id = BT_FIELD_TYPE_ID_SEQUENCE;
83509119 2748 bt_get(element_type);
273b65be
JG		 2749 sequence->element_type = element_type;
2750 sequence->length_field_name = g_string_new(length_field_name);
50842bdc 2751 bt_field_type_init(&sequence->parent, FALSE);
4e8304f7
PP		 2752 BT_LOGD("Created sequence field type object: addr=%p, "
2753 "element-ft-addr=%p, length-field-name=\"%s\"",
2754 &sequence->parent, element_type, length_field_name);
273b65be
JG		 2755 return &sequence->parent;
2756error:
2757 return NULL;
2758}
2759
50842bdc
PP		 2760struct bt_field_type *bt_field_type_sequence_get_element_type(
2761 struct bt_field_type *type)
b92ddaaa 2762{
50842bdc
PP		 2763 struct bt_field_type *ret = NULL;
2764 struct bt_field_type_sequence *sequence;
b92ddaaa 2765
4e8304f7
PP		 2766 if (!type) {
2767 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2768 goto end;
2769 }
2770
50842bdc 2771 if (type->id != BT_FIELD_TYPE_ID_SEQUENCE) {
4e8304f7
PP		 2772 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
2773 "addr=%p, ft-id=%s", type,
50842bdc 2774 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2775 goto end;
2776 }
2777
50842bdc 2778 sequence = container_of(type, struct bt_field_type_sequence,
b92ddaaa
JG		 2779 parent);
2780 ret = sequence->element_type;
83509119 2781 bt_get(ret);
b92ddaaa
JG		 2782end:
2783 return ret;
2784}
2785
626e93aa 2786BT_HIDDEN
50842bdc
PP		 2787int bt_field_type_sequence_set_element_type(struct bt_field_type *type,
2788 struct bt_field_type *element_type)
626e93aa
PP		 2789{
2790 int ret = 0;
50842bdc 2791 struct bt_field_type_sequence *sequence;
626e93aa 2792
4e8304f7
PP		 2793 if (!type) {
2794 BT_LOGW_STR("Invalid parameter: sequence field type is NULL.");
626e93aa
PP		 2795 ret = -1;
2796 goto end;
2797 }
2798
4e8304f7
PP		 2799 if (!element_type) {
2800 BT_LOGW_STR("Invalid parameter: element field type is NULL.");
2801 ret = -1;
2802 goto end;
2803 }
2804
50842bdc 2805 if (type->id != BT_FIELD_TYPE_ID_SEQUENCE) {
4e8304f7
PP		 2806 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
2807 "addr=%p, ft-id=%s", type,
50842bdc 2808 bt_field_type_id_string(type->id));
4e8304f7
PP		 2809 ret = -1;
2810 goto end;
2811 }
626e93aa 2812
50842bdc 2813 sequence = container_of(type, struct bt_field_type_sequence, parent);
626e93aa
PP		 2814 if (sequence->element_type) {
2815 BT_PUT(sequence->element_type);
2816 }
2817
2818 sequence->element_type = element_type;
2819 bt_get(sequence->element_type);
dfc1504d
PP		 2820 BT_LOGV("Set sequence field type's element field type: sequence-ft-addr=%p, "
2821 "element-ft-addr=%p", type, element_type);
626e93aa
PP		 2822
2823end:
2824 return ret;
2825}
2826
50842bdc
PP		 2827const char *bt_field_type_sequence_get_length_field_name(
2828 struct bt_field_type *type)
b92ddaaa
JG		 2829{
2830 const char *ret = NULL;
50842bdc 2831 struct bt_field_type_sequence *sequence;
b92ddaaa 2832
4e8304f7
PP		 2833 if (!type) {
2834 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2835 goto end;
2836 }
2837
50842bdc 2838 if (type->id != BT_FIELD_TYPE_ID_SEQUENCE) {
4e8304f7
PP		 2839 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
2840 "addr=%p, ft-id=%s", type,
50842bdc 2841 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2842 goto end;
2843 }
2844
50842bdc 2845 sequence = container_of(type, struct bt_field_type_sequence,
b92ddaaa
JG		 2846 parent);
2847 ret = sequence->length_field_name->str;
2848end:
2849 return ret;
2850}
2851
50842bdc 2852struct bt_field_type *bt_field_type_string_create(void)
273b65be 2853{
50842bdc
PP		 2854 struct bt_field_type_string *string =
2855 g_new0(struct bt_field_type_string, 1);
273b65be 2856
4e8304f7
PP		 2857 BT_LOGD_STR("Creating string field type object.");
2858
273b65be 2859 if (!string) {
4e8304f7 2860 BT_LOGE_STR("Failed to allocate one string field type.");
273b65be
JG		 2861 return NULL;
2862 }
2863
50842bdc
PP		 2864 string->parent.id = BT_FIELD_TYPE_ID_STRING;
2865 bt_field_type_init(&string->parent, TRUE);
2866 string->encoding = BT_STRING_ENCODING_UTF8;
dc3fffef 2867 string->parent.alignment = CHAR_BIT;
4e8304f7 2868 BT_LOGD("Created string field type object: addr=%p", &string->parent);
273b65be
JG		 2869 return &string->parent;
2870}
2871
50842bdc
PP		 2872enum bt_string_encoding bt_field_type_string_get_encoding(
2873 struct bt_field_type *type)
b92ddaaa 2874{
50842bdc
PP		 2875 struct bt_field_type_string *string;
2876 enum bt_string_encoding ret = BT_STRING_ENCODING_UNKNOWN;
b92ddaaa 2877
4e8304f7
PP		 2878 if (!type) {
2879 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2880 goto end;
2881 }
2882
50842bdc 2883 if (type->id != BT_FIELD_TYPE_ID_STRING) {
4e8304f7
PP		 2884 BT_LOGW("Invalid parameter: field type is not a string field type: "
2885 "addr=%p, ft-id=%s", type,
50842bdc 2886 bt_field_type_id_string(type->id));
b92ddaaa
JG		 2887 goto end;
2888 }
2889
50842bdc 2890 string = container_of(type, struct bt_field_type_string,
b92ddaaa 2891 parent);
dc3fffef 2892 ret = string->encoding;
b92ddaaa
JG		 2893end:
2894 return ret;
2895}
2896
50842bdc
PP		 2897int bt_field_type_string_set_encoding(struct bt_field_type *type,
2898 enum bt_string_encoding encoding)
273b65be
JG		 2899{
2900 int ret = 0;
50842bdc 2901 struct bt_field_type_string *string;
273b65be 2902
4e8304f7
PP		 2903 if (!type) {
2904 BT_LOGW_STR("Invalid parameter: field type is NULL.");
2905 ret = -1;
2906 goto end;
2907 }
2908
50842bdc 2909 if (type->id != BT_FIELD_TYPE_ID_STRING) {
4e8304f7
PP		 2910 BT_LOGW("Invalid parameter: field type is not a string field type: "
2911 "addr=%p, ft-id=%s", type,
50842bdc 2912 bt_field_type_id_string(type->id));
4e8304f7
PP		 2913 ret = -1;
2914 goto end;
2915 }
2916
50842bdc
PP		 2917 if (encoding != BT_STRING_ENCODING_UTF8 &&
2918 encoding != BT_STRING_ENCODING_ASCII) {
4e8304f7
PP		 2919 BT_LOGW("Invalid parameter: unknown string encoding: "
2920 "addr=%p, encoding=%d", type, encoding);
273b65be
JG		 2921 ret = -1;
2922 goto end;
2923 }
2924
50842bdc 2925 string = container_of(type, struct bt_field_type_string, parent);
dc3fffef 2926 string->encoding = encoding;
dfc1504d 2927 BT_LOGV("Set string field type's encoding: addr=%p, encoding=%s",
50842bdc 2928 type, bt_string_encoding_string(encoding));
273b65be
JG		 2929end:
2930 return ret;
2931}
2932
50842bdc 2933int bt_field_type_get_alignment(struct bt_field_type *type)
b92ddaaa
JG		 2934{
2935 int ret;
50842bdc 2936 enum bt_field_type_id type_id;
b92ddaaa
JG		 2937
2938 if (!type) {
4e8304f7 2939 BT_LOGW_STR("Invalid parameter: field type is NULL.");
b92ddaaa
JG		 2940 ret = -1;
2941 goto end;
2942 }
2943
3ffba961 2944 if (type->frozen) {
dc3fffef 2945 ret = (int) type->alignment;
3ffba961
JG		 2946 goto end;
2947 }
2948
50842bdc 2949 type_id = bt_field_type_get_type_id(type);
3ffba961 2950 switch (type_id) {
50842bdc 2951 case BT_FIELD_TYPE_ID_SEQUENCE:
3ffba961 2952 {
50842bdc
PP		 2953 struct bt_field_type *element =
2954 bt_field_type_sequence_get_element_type(type);
3ffba961 2955
4e8304f7 2956 assert(element);
50842bdc 2957 ret = bt_field_type_get_alignment(element);
83509119 2958 bt_put(element);
3ffba961
JG		 2959 break;
2960 }
50842bdc 2961 case BT_FIELD_TYPE_ID_ARRAY:
3ffba961 2962 {
50842bdc
PP		 2963 struct bt_field_type *element =
2964 bt_field_type_array_get_element_type(type);
3ffba961 2965
4e8304f7 2966 assert(element);
50842bdc 2967 ret = bt_field_type_get_alignment(element);
83509119 2968 bt_put(element);
3ffba961
JG		 2969 break;
2970 }
50842bdc 2971 case BT_FIELD_TYPE_ID_STRUCT:
3ffba961 2972 {
544d0515 2973 int64_t i, element_count;
3ffba961 2974
50842bdc 2975 element_count = bt_field_type_structure_get_field_count(
3ffba961 2976 type);
4e8304f7 2977 assert(element_count >= 0);
3ffba961
JG		 2978
2979 for (i = 0; i < element_count; i++) {
bc85036f 2980 struct bt_field_type *field = NULL;
3ffba961
JG		 2981 int field_alignment;
2982
50842bdc 2983 ret = bt_field_type_structure_get_field_by_index(
9ac68eb1 2984 type, NULL, &field, i);
4e8304f7 2985 assert(ret == 0);
3ffba961 2986 assert(field);
50842bdc 2987 field_alignment = bt_field_type_get_alignment(
3ffba961 2988 field);
83509119 2989 bt_put(field);
3ffba961
JG		 2990 if (field_alignment < 0) {
2991 ret = field_alignment;
2992 goto end;
2993 }
2994
dc3fffef 2995 type->alignment = MAX(field_alignment, type->alignment);
3ffba961 2996 }
dc3fffef 2997 ret = (int) type->alignment;
3ffba961
JG		 2998 break;
2999 }
50842bdc 3000 case BT_FIELD_TYPE_ID_UNKNOWN:
4e8304f7
PP		 3001 BT_LOGW("Invalid parameter: unknown field type ID: "
3002 "addr=%p, ft-id=%d", type, type_id);
3ffba961
JG		 3003 ret = -1;
3004 break;
3005 default:
dc3fffef 3006 ret = (int) type->alignment;
3ffba961
JG		 3007 break;
3008 }
b92ddaaa
JG		 3009end:
3010 return ret;
3011}
3012
9ad2f879
PP		 3013static inline
3014int is_power_of_two(unsigned int value)
3015{
3016 return ((value & (value - 1)) == 0) && value > 0;
3017}
3018
50842bdc 3019int bt_field_type_set_alignment(struct bt_field_type *type,
273b65be
JG		 3020 unsigned int alignment)
3021{
3022 int ret = 0;
50842bdc 3023 enum bt_field_type_id type_id;
273b65be 3024
9ad2f879 3025 /* Alignment must be a power of two */
4e8304f7
PP		 3026 if (!type) {
3027 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3028 ret = -1;
3029 goto end;
3030 }
3031
3032 if (type->frozen) {
3033 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
3034 type);
3035 ret = -1;
3036 goto end;
3037 }
3038
3039 if (!is_power_of_two(alignment)) {
3040 BT_LOGW("Invalid parameter: alignment is not a power of two: "
3041 "addr=%p, align=%u", type, alignment);
273b65be
JG		 3042 ret = -1;
3043 goto end;
3044 }
3045
50842bdc
PP		 3046 type_id = bt_field_type_get_type_id(type);
3047 if (type_id == BT_FIELD_TYPE_ID_UNKNOWN) {
4e8304f7
PP		 3048 BT_LOGW("Invalid parameter: unknown field type ID: "
3049 "addr=%p, ft-id=%d", type, type_id);
6a43d732
JG		 3050 ret = -1;
3051 goto end;
3052 }
3053
50842bdc 3054 if (type->id == BT_FIELD_TYPE_ID_STRING &&
4e8304f7
PP		 3055 alignment != CHAR_BIT) {
3056 BT_LOGW("Invalid parameter: alignment must be %u for a string field type: "
3057 "addr=%p, align=%u", CHAR_BIT, type, alignment);
273b65be
JG		 3058 ret = -1;
3059 goto end;
3060 }
3061
50842bdc
PP		 3062 if (type_id == BT_FIELD_TYPE_ID_VARIANT ||
3063 type_id == BT_FIELD_TYPE_ID_SEQUENCE ||
3064 type_id == BT_FIELD_TYPE_ID_ARRAY) {
6a43d732 3065 /* Setting an alignment on these types makes no sense */
4e8304f7
PP		 3066 BT_LOGW("Invalid parameter: cannot set the alignment of this field type: "
3067 "addr=%p, ft-id=%s", type,
50842bdc 3068 bt_field_type_id_string(type->id));
6a43d732
JG		 3069 ret = -1;
3070 goto end;
3071 }
3072
dc3fffef 3073 type->alignment = alignment;
273b65be 3074 ret = 0;
dfc1504d
PP		 3075 BT_LOGV("Set field type's alignment: addr=%p, align=%u",
3076 type, alignment);
273b65be
JG		 3077end:
3078 return ret;
3079}
3080
50842bdc
PP		 3081enum bt_byte_order bt_field_type_get_byte_order(
3082 struct bt_field_type *type)
b92ddaaa 3083{
50842bdc 3084 enum bt_byte_order ret = BT_BYTE_ORDER_UNKNOWN;
b92ddaaa
JG		 3085
3086 if (!type) {
4e8304f7 3087 BT_LOGW_STR("Invalid parameter: field type is NULL.");
b92ddaaa
JG		 3088 goto end;
3089 }
3090
dc3fffef 3091 switch (type->id) {
50842bdc 3092 case BT_FIELD_TYPE_ID_INTEGER:
b92ddaaa 3093 {
50842bdc
PP		 3094 struct bt_field_type_integer *integer = container_of(
3095 type, struct bt_field_type_integer, parent);
445c3471 3096 ret = integer->user_byte_order;
b92ddaaa
JG		 3097 break;
3098 }
50842bdc 3099 case BT_FIELD_TYPE_ID_ENUM:
4b2da5f0 3100 {
50842bdc
PP		 3101 struct bt_field_type_enumeration *enum_ft = container_of(
3102 type, struct bt_field_type_enumeration, parent);
3103 ret = bt_field_type_get_byte_order(enum_ft->container);
4b2da5f0
PP		 3104 break;
3105 }
50842bdc 3106 case BT_FIELD_TYPE_ID_FLOAT:
b92ddaaa 3107 {
50842bdc 3108 struct bt_field_type_floating_point *floating_point =
b92ddaaa 3109 container_of(type,
50842bdc 3110 struct bt_field_type_floating_point,
b92ddaaa 3111 parent);
445c3471 3112 ret = floating_point->user_byte_order;
b92ddaaa
JG		 3113 break;
3114 }
3115 default:
4e8304f7
PP		 3116 BT_LOGW("Invalid parameter: cannot get the byte order of this field type: "
3117 "addr=%p, ft-id=%s", type,
50842bdc 3118 bt_field_type_id_string(type->id));
c35a1669
JG		 3119 goto end;
3120 }
3121
50842bdc
PP		 3122 assert(ret == BT_BYTE_ORDER_NATIVE ||
3123 ret == BT_BYTE_ORDER_LITTLE_ENDIAN ||
3124 ret == BT_BYTE_ORDER_BIG_ENDIAN ||
3125 ret == BT_BYTE_ORDER_NETWORK);
445c3471 3126
b92ddaaa
JG		 3127end:
3128 return ret;
3129}
3130
50842bdc
PP		 3131int bt_field_type_set_byte_order(struct bt_field_type *type,
3132 enum bt_byte_order byte_order)
273b65be
JG		 3133{
3134 int ret = 0;
273b65be 3135
4e8304f7
PP		 3136 if (!type) {
3137 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3138 ret = -1;
3139 goto end;
3140 }
3141
3142 if (type->frozen) {
3143 BT_LOGW("Invalid parameter: field type is frozen: addr=%p",
3144 type);
273b65be
JG		 3145 ret = -1;
3146 goto end;
3147 }
3148
50842bdc
PP		 3149 if (byte_order != BT_BYTE_ORDER_NATIVE &&
3150 byte_order != BT_BYTE_ORDER_LITTLE_ENDIAN &&
3151 byte_order != BT_BYTE_ORDER_BIG_ENDIAN &&
3152 byte_order != BT_BYTE_ORDER_NETWORK) {
d41cff38 3153 BT_LOGW("Invalid parameter: invalid byte order: "
4e8304f7 3154 "addr=%p, bo=%s", type,
50842bdc 3155 bt_byte_order_string(byte_order));
273b65be
JG		 3156 ret = -1;
3157 goto end;
3158 }
3159
dc3fffef
PP		 3160 if (set_byte_order_funcs[type->id]) {
3161 set_byte_order_funcs[type->id](type, byte_order);
273b65be 3162 }
dfc1504d
PP		 3163
3164 BT_LOGV("Set field type's byte order: addr=%p, bo=%s",
50842bdc 3165 type, bt_byte_order_string(byte_order));
dfc1504d 3166
273b65be
JG		 3167end:
3168 return ret;
3169}
3170
50842bdc
PP		 3171enum bt_field_type_id bt_field_type_get_type_id(
3172 struct bt_field_type *type)
b92ddaaa
JG		 3173{
3174 if (!type) {
4e8304f7 3175 BT_LOGW_STR("Invalid parameter: field type is NULL.");
50842bdc 3176 return BT_FIELD_TYPE_ID_UNKNOWN;
b92ddaaa
JG		 3177 }
3178
dc3fffef 3179 return type->id;
b92ddaaa 3180}
2f2d8e05 3181
50842bdc 3182int bt_field_type_is_integer(struct bt_field_type *type)
56db8d7a 3183{
50842bdc 3184 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_INTEGER;
56db8d7a
PP		 3185}
3186
50842bdc 3187int bt_field_type_is_floating_point(struct bt_field_type *type)
56db8d7a 3188{
50842bdc 3189 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_FLOAT;
56db8d7a
PP		 3190}
3191
50842bdc 3192int bt_field_type_is_enumeration(struct bt_field_type *type)
56db8d7a 3193{
50842bdc 3194 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_ENUM;
56db8d7a
PP		 3195}
3196
50842bdc 3197int bt_field_type_is_string(struct bt_field_type *type)
56db8d7a 3198{
50842bdc 3199 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_STRING;
56db8d7a
PP		 3200}
3201
50842bdc 3202int bt_field_type_is_structure(struct bt_field_type *type)
56db8d7a 3203{
50842bdc 3204 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_STRUCT;
56db8d7a
PP		 3205}
3206
50842bdc 3207int bt_field_type_is_array(struct bt_field_type *type)
56db8d7a 3208{
50842bdc 3209 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_ARRAY;
56db8d7a
PP		 3210}
3211
50842bdc 3212int bt_field_type_is_sequence(struct bt_field_type *type)
56db8d7a 3213{
50842bdc 3214 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_SEQUENCE;
56db8d7a
PP		 3215}
3216
50842bdc 3217int bt_field_type_is_variant(struct bt_field_type *type)
56db8d7a 3218{
50842bdc 3219 return bt_field_type_get_type_id(type) == BT_FIELD_TYPE_ID_VARIANT;
56db8d7a
PP		 3220}
3221
4e8304f7 3222/* Pre-2.0 CTF writer backward compatibility */
50842bdc 3223void bt_ctf_field_type_get(struct bt_field_type *type)
273b65be 3224{
83509119 3225 bt_get(type);
273b65be
JG		 3226}
3227
4e8304f7 3228/* Pre-2.0 CTF writer backward compatibility */
50842bdc 3229void bt_ctf_field_type_put(struct bt_field_type *type)
273b65be 3230{
83509119 3231 bt_put(type);
273b65be
JG		 3232}
3233
3234BT_HIDDEN
50842bdc 3235void bt_field_type_freeze(struct bt_field_type *type)
273b65be 3236{
4e8304f7 3237 if (!type || type->frozen) {
273b65be
JG		 3238 return;
3239 }
3240
3241 type->freeze(type);
3242}
3243
3244BT_HIDDEN
50842bdc
PP		 3245struct bt_field_type *bt_field_type_variant_get_field_type_signed(
3246 struct bt_field_type_variant *variant,
b92ddaaa 3247 int64_t tag_value)
273b65be 3248{
50842bdc 3249 struct bt_field_type *type = NULL;
b92ddaaa
JG		 3250 GQuark field_name_quark;
3251 gpointer index;
3252 struct structure_field *field_entry;
3253 struct range_overlap_query query = {
3254 .range_start._signed = tag_value,
3255 .range_end._signed = tag_value,
96e8f959
MD		 3256 .mapping_name = 0,
3257 .overlaps = 0,
3258 };
273b65be 3259
b92ddaaa
JG		 3260 g_ptr_array_foreach(variant->tag->entries, check_ranges_overlap,
3261 &query);
3262 if (!query.overlaps) {
273b65be
JG		 3263 goto end;
3264 }
3265
b92ddaaa
JG		 3266 field_name_quark = query.mapping_name;
3267 if (!g_hash_table_lookup_extended(variant->field_name_to_index,
ec159b1e 3268 GUINT_TO_POINTER(field_name_quark), NULL, &index)) {
273b65be
JG		 3269 goto end;
3270 }
3271
e54fab7e 3272 field_entry = g_ptr_array_index(variant->fields, (size_t) index);
b92ddaaa 3273 type = field_entry->type;
273b65be
JG		 3274end:
3275 return type;
3276}
3277
3278BT_HIDDEN
50842bdc
PP		 3279struct bt_field_type *bt_field_type_variant_get_field_type_unsigned(
3280 struct bt_field_type_variant *variant,
b92ddaaa 3281 uint64_t tag_value)
273b65be 3282{
50842bdc 3283 struct bt_field_type *type = NULL;
273b65be
JG		 3284 GQuark field_name_quark;
3285 gpointer index;
3286 struct structure_field *field_entry;
b92ddaaa
JG		 3287 struct range_overlap_query query = {
3288 .range_start._unsigned = tag_value,
3289 .range_end._unsigned = tag_value,
96e8f959
MD		 3290 .mapping_name = 0,
3291 .overlaps = 0,
3292 };
273b65be 3293
b92ddaaa
JG		 3294 g_ptr_array_foreach(variant->tag->entries,
3295 check_ranges_overlap_unsigned,
273b65be
JG		 3296 &query);
3297 if (!query.overlaps) {
3298 goto end;
3299 }
3300
3301 field_name_quark = query.mapping_name;
3302 if (!g_hash_table_lookup_extended(variant->field_name_to_index,
3303 GUINT_TO_POINTER(field_name_quark), NULL, &index)) {
3304 goto end;
3305 }
3306
3307 field_entry = g_ptr_array_index(variant->fields, (size_t)index);
3308 type = field_entry->type;
3309end:
3310 return type;
3311}
3312
3313BT_HIDDEN
50842bdc 3314int bt_field_type_serialize(struct bt_field_type *type,
273b65be
JG		 3315 struct metadata_context *context)
3316{
3317 int ret;
3318
4e8304f7
PP		 3319 assert(type);
3320 assert(context);
3321
81e36fac 3322 /* Make sure field type is valid before serializing it */
50842bdc 3323 ret = bt_field_type_validate(type);
81e36fac 3324 if (ret) {
f45cd48c
PP		 3325 BT_LOGW("Cannot serialize field type's metadata: field type is invalid: "
3326 "addr=%p", type);
81e36fac
PP		 3327 goto end;
3328 }
3329
273b65be
JG		 3330 ret = type->serialize(type, context);
3331end:
3332 return ret;
3333}
3334
50842bdc 3335struct bt_field_type *bt_field_type_copy(struct bt_field_type *type)
24724933 3336{
50842bdc 3337 struct bt_field_type *copy = NULL;
24724933
JG		 3338
3339 if (!type) {
4e8304f7 3340 BT_LOGW_STR("Invalid parameter: field type is NULL.");
24724933
JG		 3341 goto end;
3342 }
3343
dc3fffef 3344 copy = type_copy_funcs[type->id](type);
4e8304f7
PP		 3345 if (!copy) {
3346 BT_LOGE_STR("Cannot copy field type.");
3347 goto end;
3348 }
3349
dc3fffef 3350 copy->alignment = type->alignment;
24724933
JG		 3351end:
3352 return copy;
3353}
3354
39a5e0db 3355BT_HIDDEN
50842bdc
PP		 3356int bt_field_type_structure_get_field_name_index(
3357 struct bt_field_type *type, const char *name)
39a5e0db
JG		 3358{
3359 int ret;
3360 size_t index;
3361 GQuark name_quark;
50842bdc 3362 struct bt_field_type_structure *structure;
39a5e0db 3363
4e8304f7
PP		 3364 if (!type) {
3365 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3366 ret = -1;
3367 goto end;
3368 }
3369
3370 if (!name) {
3371 BT_LOGW_STR("Invalid parameter: field name is NULL.");
3372 ret = -1;
3373 goto end;
3374 }
3375
50842bdc 3376 if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_STRUCT) {
4e8304f7
PP		 3377 BT_LOGW("Invalid parameter: field type is not a structure field type: "
3378 "addr=%p, ft-id=%s", type,
50842bdc 3379 bt_field_type_id_string(type->id));
39a5e0db
JG		 3380 ret = -1;
3381 goto end;
3382 }
3383
3384 name_quark = g_quark_try_string(name);
3385 if (!name_quark) {
6fa8d37b
PP		 3386 BT_LOGV("No such structure field type field name: "
3387 "ft-addr=%p, field-name=\"%s\"",
3388 type, name);
39a5e0db
JG		 3389 ret = -1;
3390 goto end;
3391 }
3392
50842bdc 3393 structure = container_of(type, struct bt_field_type_structure,
39a5e0db
JG		 3394 parent);
3395 if (!g_hash_table_lookup_extended(structure->field_name_to_index,
ec159b1e
PP		 3396 GUINT_TO_POINTER(name_quark),
3397 NULL, (gpointer *)&index)) {
6fa8d37b
PP		 3398 BT_LOGV("No such structure field type field name: "
3399 "ft-addr=%p, field-name=\"%s\"",
3400 type, name);
39a5e0db
JG		 3401 ret = -1;
3402 goto end;
3403 }
3404 ret = (int) index;
3405end:
3406 return ret;
3407}
736133f1
JG		 3408
3409BT_HIDDEN
50842bdc
PP		 3410int bt_field_type_variant_get_field_name_index(
3411 struct bt_field_type *type, const char *name)
736133f1
JG		 3412{
3413 int ret;
3414 size_t index;
3415 GQuark name_quark;
50842bdc 3416 struct bt_field_type_variant *variant;
736133f1 3417
4e8304f7
PP		 3418 if (!type) {
3419 BT_LOGW_STR("Invalid parameter: variant field type is NULL.");
3420 ret = -1;
3421 goto end;
3422 }
3423
3424 if (!name) {
3425 BT_LOGW_STR("Invalid parameter: field name is NULL.");
3426 ret = -1;
3427 goto end;
3428 }
3429
50842bdc 3430 if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 3431 BT_LOGW("Invalid parameter: field type is not a variant field type: "
3432 "addr=%p, ft-id=%s", type,
50842bdc 3433 bt_field_type_id_string(type->id));
736133f1
JG		 3434 ret = -1;
3435 goto end;
3436 }
3437
3438 name_quark = g_quark_try_string(name);
3439 if (!name_quark) {
6fa8d37b
PP		 3440 BT_LOGV("No such variant field type field name: "
3441 "ft-addr=%p, field-name=\"%s\"",
3442 type, name);
736133f1
JG		 3443 ret = -1;
3444 goto end;
3445 }
3446
50842bdc 3447 variant = container_of(type, struct bt_field_type_variant,
736133f1
JG		 3448 parent);
3449 if (!g_hash_table_lookup_extended(variant->field_name_to_index,
ec159b1e
PP		 3450 GUINT_TO_POINTER(name_quark),
3451 NULL, (gpointer *)&index)) {
6fa8d37b
PP		 3452 BT_LOGV("No such variant field type field name: "
3453 "ft-addr=%p, field-name=\"%s\"",
3454 type, name);
736133f1
JG		 3455 ret = -1;
3456 goto end;
3457 }
3458 ret = (int) index;
3459end:
3460 return ret;
3461}
aa4e271c
JG		 3462
3463BT_HIDDEN
50842bdc
PP		 3464int bt_field_type_sequence_set_length_field_path(
3465 struct bt_field_type *type,
3466 struct bt_field_path *path)
aa4e271c
JG		 3467{
3468 int ret = 0;
50842bdc 3469 struct bt_field_type_sequence *sequence;
aa4e271c 3470
4e8304f7
PP		 3471 if (!type) {
3472 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3473 ret = -1;
3474 goto end;
3475 }
3476
50842bdc 3477 if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_SEQUENCE) {
4e8304f7
PP		 3478 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
3479 "addr=%p, ft-id=%s", type,
50842bdc 3480 bt_field_type_id_string(type->id));
aa4e271c
JG		 3481 ret = -1;
3482 goto end;
3483 }
3484
50842bdc 3485 sequence = container_of(type, struct bt_field_type_sequence,
aa4e271c 3486 parent);
b011f6b0
PP		 3487 bt_get(path);
3488 BT_MOVE(sequence->length_field_path, path);
dfc1504d
PP		 3489 BT_LOGV("Set sequence field type's length field path: ft-addr=%p, "
3490 "field-path-addr=%p", type, path);
aa4e271c
JG		 3491end:
3492 return ret;
3493}
4a1e8671
JG		 3494
3495BT_HIDDEN
50842bdc
PP		 3496int bt_field_type_variant_set_tag_field_path(struct bt_field_type *type,
3497 struct bt_field_path *path)
4a1e8671
JG		 3498{
3499 int ret = 0;
50842bdc 3500 struct bt_field_type_variant *variant;
4a1e8671 3501
4e8304f7
PP		 3502 if (!type) {
3503 BT_LOGW_STR("Invalid parameter: field type is NULL.");
3504 ret = -1;
3505 goto end;
3506 }
3507
50842bdc 3508 if (bt_field_type_get_type_id(type) != BT_FIELD_TYPE_ID_VARIANT) {
4e8304f7
PP		 3509 BT_LOGW("Invalid parameter: field type is not a variant field type: "
3510 "addr=%p, ft-id=%s", type,
50842bdc 3511 bt_field_type_id_string(type->id));
4a1e8671
JG		 3512 ret = -1;
3513 goto end;
3514 }
3515
50842bdc 3516 variant = container_of(type, struct bt_field_type_variant,
4a1e8671 3517 parent);
b011f6b0
PP		 3518 bt_get(path);
3519 BT_MOVE(variant->tag_field_path, path);
dfc1504d
PP		 3520 BT_LOGV("Set variant field type's tag field path: ft-addr=%p, "
3521 "field-path-addr=%p", type, path);
4a1e8671
JG		 3522end:
3523 return ret;
3524}
3f39933a
JG		 3525
3526BT_HIDDEN
50842bdc
PP		 3527int bt_field_type_variant_set_tag_field_type(struct bt_field_type *type,
3528 struct bt_field_type *tag)
3f39933a
JG		 3529{
3530 int ret = 0;
50842bdc 3531 struct bt_field_type_variant *variant;
3f39933a 3532
4e8304f7
PP		 3533 if (!type) {
3534 BT_LOGW_STR("Invalid parameter: variant field type is NULL.");
3f39933a
JG		 3535 ret = -1;
3536 goto end;
3537 }
3538
4e8304f7
PP		 3539 if (!tag) {
3540 BT_LOGW_STR("Invalid parameter: tag field type is NULL.");
3541 ret = -1;
3542 goto end;
3f39933a 3543 }
5cec03e4 3544
50842bdc 3545 if (bt_field_type_get_type_id(tag) != BT_FIELD_TYPE_ID_ENUM) {
4e8304f7
PP		 3546 BT_LOGW("Invalid parameter: field type is not an enumeration field type: "
3547 "addr=%p, ft-id=%s", type,
50842bdc 3548 bt_field_type_id_string(type->id));
5cec03e4
JG		 3549 ret = -1;
3550 goto end;
3551 }
3552
50842bdc 3553 variant = container_of(type, struct bt_field_type_variant,
5cec03e4 3554 parent);
4e8304f7
PP		 3555 bt_get(tag);
3556 if (variant->tag) {
3557 bt_put(&variant->tag->parent);
5cec03e4 3558 }
50842bdc 3559 variant->tag = container_of(tag, struct bt_field_type_enumeration,
4e8304f7 3560 parent);
dfc1504d
PP		 3561 BT_LOGV("Set variant field type's tag field type: variant-ft-addr=%p, "
3562 "tag-ft-addr=%p", type, tag);
5cec03e4
JG		 3563end:
3564 return ret;
3565}
3566
273b65be 3567static
50842bdc 3568void bt_field_type_integer_destroy(struct bt_field_type *type)
273b65be 3569{
50842bdc
PP		 3570 struct bt_field_type_integer *integer =
3571 (struct bt_field_type_integer *) type;
273b65be 3572
de3dd40e 3573 if (!type) {
273b65be
JG		 3574 return;
3575 }
3576
4e8304f7 3577 BT_LOGD("Destroying integer field type object: addr=%p", type);
ec159b1e 3578 BT_LOGD_STR("Putting mapped clock class.");
83509119 3579 bt_put(integer->mapped_clock);
273b65be
JG		 3580 g_free(integer);
3581}
3582
3583static
50842bdc 3584void bt_field_type_enumeration_destroy(struct bt_field_type *type)
273b65be 3585{
50842bdc
PP		 3586 struct bt_field_type_enumeration *enumeration =
3587 (struct bt_field_type_enumeration *) type;
273b65be 3588
de3dd40e 3589 if (!type) {
273b65be
JG		 3590 return;
3591 }
3592
4e8304f7 3593 BT_LOGD("Destroying enumeration field type object: addr=%p", type);
273b65be 3594 g_ptr_array_free(enumeration->entries, TRUE);
ec159b1e 3595 BT_LOGD_STR("Putting container field type.");
83509119 3596 bt_put(enumeration->container);
273b65be
JG		 3597 g_free(enumeration);
3598}
3599
3600static
50842bdc 3601void bt_field_type_floating_point_destroy(struct bt_field_type *type)
273b65be 3602{
50842bdc
PP		 3603 struct bt_field_type_floating_point *floating_point =
3604 (struct bt_field_type_floating_point *) type;
273b65be 3605
de3dd40e 3606 if (!type) {
273b65be
JG		 3607 return;
3608 }
3609
4e8304f7 3610 BT_LOGD("Destroying floating point number field type object: addr=%p", type);
273b65be
JG		 3611 g_free(floating_point);
3612}
3613
3614static
50842bdc 3615void bt_field_type_structure_destroy(struct bt_field_type *type)
273b65be 3616{
50842bdc
PP		 3617 struct bt_field_type_structure *structure =
3618 (struct bt_field_type_structure *) type;
273b65be 3619
de3dd40e 3620 if (!type) {
273b65be
JG		 3621 return;
3622 }
3623
4e8304f7 3624 BT_LOGD("Destroying structure field type object: addr=%p", type);
273b65be
JG		 3625 g_ptr_array_free(structure->fields, TRUE);
3626 g_hash_table_destroy(structure->field_name_to_index);
3627 g_free(structure);
3628}
3629
3630static
50842bdc 3631void bt_field_type_variant_destroy(struct bt_field_type *type)
273b65be 3632{
50842bdc
PP		 3633 struct bt_field_type_variant *variant =
3634 (struct bt_field_type_variant *) type;
273b65be 3635
de3dd40e 3636 if (!type) {
273b65be
JG		 3637 return;
3638 }
3639
4e8304f7 3640 BT_LOGD("Destroying variant field type object: addr=%p", type);
273b65be
JG		 3641 g_ptr_array_free(variant->fields, TRUE);
3642 g_hash_table_destroy(variant->field_name_to_index);
3643 g_string_free(variant->tag_name, TRUE);
ec159b1e 3644 BT_LOGD_STR("Putting tag field type.");
83509119 3645 bt_put(&variant->tag->parent);
b011f6b0 3646 BT_PUT(variant->tag_field_path);
273b65be
JG		 3647 g_free(variant);
3648}
3649
3650static
50842bdc 3651void bt_field_type_array_destroy(struct bt_field_type *type)
273b65be 3652{
50842bdc
PP		 3653 struct bt_field_type_array *array =
3654 (struct bt_field_type_array *) type;
273b65be 3655
de3dd40e 3656 if (!type) {
273b65be
JG		 3657 return;
3658 }
3659
4e8304f7 3660 BT_LOGD("Destroying array field type object: addr=%p", type);
ec159b1e 3661 BT_LOGD_STR("Putting element field type.");
83509119 3662 bt_put(array->element_type);
273b65be
JG		 3663 g_free(array);
3664}
3665
3666static
50842bdc 3667void bt_field_type_sequence_destroy(struct bt_field_type *type)
273b65be 3668{
50842bdc
PP		 3669 struct bt_field_type_sequence *sequence =
3670 (struct bt_field_type_sequence *) type;
273b65be 3671
de3dd40e 3672 if (!type) {
273b65be
JG		 3673 return;
3674 }
3675
4e8304f7 3676 BT_LOGD("Destroying sequence field type object: addr=%p", type);
ec159b1e 3677 BT_LOGD_STR("Putting element field type.");
83509119 3678 bt_put(sequence->element_type);
273b65be 3679 g_string_free(sequence->length_field_name, TRUE);
ec159b1e 3680 BT_LOGD_STR("Putting length field path.");
b011f6b0 3681 BT_PUT(sequence->length_field_path);
273b65be
JG		 3682 g_free(sequence);
3683}
3684
3685static
50842bdc 3686void bt_field_type_string_destroy(struct bt_field_type *type)
273b65be 3687{
50842bdc
PP		 3688 struct bt_field_type_string *string =
3689 (struct bt_field_type_string *) type;
273b65be 3690
de3dd40e 3691 if (!type) {
273b65be
JG		 3692 return;
3693 }
3694
4e8304f7 3695 BT_LOGD("Destroying string field type object: addr=%p", type);
273b65be
JG		 3696 g_free(string);
3697}
3698
3699static
50842bdc 3700void generic_field_type_freeze(struct bt_field_type *type)
273b65be
JG		 3701{
3702 type->frozen = 1;
3703}
3704
586411e5 3705static
50842bdc 3706void bt_field_type_integer_freeze(struct bt_field_type *type)
586411e5 3707{
50842bdc
PP		 3708 struct bt_field_type_integer *integer_type = container_of(
3709 type, struct bt_field_type_integer, parent);
586411e5 3710
4e8304f7
PP		 3711 BT_LOGD("Freezing integer field type object: addr=%p", type);
3712
586411e5 3713 if (integer_type->mapped_clock) {
ec159b1e 3714 BT_LOGD_STR("Freezing integer field type's mapped clock class.");
50842bdc 3715 bt_clock_class_freeze(integer_type->mapped_clock);
586411e5
PP		 3716 }
3717
3718 generic_field_type_freeze(type);
3719}
3720
273b65be 3721static
50842bdc 3722void bt_field_type_enumeration_freeze(struct bt_field_type *type)
273b65be 3723{
50842bdc
PP		 3724 struct bt_field_type_enumeration *enumeration_type = container_of(
3725 type, struct bt_field_type_enumeration, parent);
273b65be 3726
4e8304f7 3727 BT_LOGD("Freezing enumeration field type object: addr=%p", type);
d49e1284 3728 set_enumeration_range_overlap(type);
273b65be 3729 generic_field_type_freeze(type);
225f3384
PP		 3730 BT_LOGD("Freezing enumeration field type object's container field type: int-ft-addr=%p",
3731 enumeration_type->container);
50842bdc 3732 bt_field_type_freeze(enumeration_type->container);
273b65be
JG		 3733}
3734
3735static
3736void freeze_structure_field(struct structure_field *field)
3737{
225f3384
PP		 3738 BT_LOGD("Freezing structure/variant field type field: field-addr=%p, "
3739 "field-ft-addr=%p, field-name=\"%s\"", field,
3740 field->type, g_quark_to_string(field->name));
50842bdc 3741 bt_field_type_freeze(field->type);
273b65be
JG		 3742}
3743
3744static
50842bdc 3745void bt_field_type_structure_freeze(struct bt_field_type *type)
273b65be 3746{
50842bdc
PP		 3747 struct bt_field_type_structure *structure_type = container_of(
3748 type, struct bt_field_type_structure, parent);
273b65be 3749
3ffba961 3750 /* Cache the alignment */
4e8304f7 3751 BT_LOGD("Freezing structure field type object: addr=%p", type);
50842bdc 3752 type->alignment = bt_field_type_get_alignment(type);
273b65be 3753 generic_field_type_freeze(type);
3ffba961
JG		 3754 g_ptr_array_foreach(structure_type->fields,
3755 (GFunc) freeze_structure_field, NULL);
273b65be
JG		 3756}
3757
3758static
50842bdc 3759void bt_field_type_variant_freeze(struct bt_field_type *type)
273b65be 3760{
50842bdc
PP		 3761 struct bt_field_type_variant *variant_type = container_of(
3762 type, struct bt_field_type_variant, parent);
273b65be 3763
4e8304f7 3764 BT_LOGD("Freezing variant field type object: addr=%p", type);
273b65be 3765 generic_field_type_freeze(type);
3ffba961
JG		 3766 g_ptr_array_foreach(variant_type->fields,
3767 (GFunc) freeze_structure_field, NULL);
273b65be
JG		 3768}
3769
3770static
50842bdc 3771void bt_field_type_array_freeze(struct bt_field_type *type)
273b65be 3772{
50842bdc
PP		 3773 struct bt_field_type_array *array_type = container_of(
3774 type, struct bt_field_type_array, parent);
273b65be 3775
3ffba961 3776 /* Cache the alignment */
4e8304f7 3777 BT_LOGD("Freezing array field type object: addr=%p", type);
50842bdc 3778 type->alignment = bt_field_type_get_alignment(type);
273b65be 3779 generic_field_type_freeze(type);
225f3384
PP		 3780 BT_LOGD("Freezing array field type object's element field type: element-ft-addr=%p",
3781 array_type->element_type);
50842bdc 3782 bt_field_type_freeze(array_type->element_type);
273b65be
JG		 3783}
3784
3785static
50842bdc 3786void bt_field_type_sequence_freeze(struct bt_field_type *type)
273b65be 3787{
50842bdc
PP		 3788 struct bt_field_type_sequence *sequence_type = container_of(
3789 type, struct bt_field_type_sequence, parent);
273b65be 3790
3ffba961 3791 /* Cache the alignment */
4e8304f7 3792 BT_LOGD("Freezing sequence field type object: addr=%p", type);
50842bdc 3793 type->alignment = bt_field_type_get_alignment(type);
273b65be 3794 generic_field_type_freeze(type);
225f3384
PP		 3795 BT_LOGD("Freezing sequence field type object's element field type: element-ft-addr=%p",
3796 sequence_type->element_type);
50842bdc 3797 bt_field_type_freeze(sequence_type->element_type);
273b65be
JG		 3798}
3799
3800static
50842bdc 3801const char *get_encoding_string(enum bt_string_encoding encoding)
273b65be
JG		 3802{
3803 const char *encoding_string;
3804
3805 switch (encoding) {
50842bdc 3806 case BT_STRING_ENCODING_NONE:
273b65be
JG		 3807 encoding_string = "none";
3808 break;
50842bdc 3809 case BT_STRING_ENCODING_ASCII:
273b65be
JG		 3810 encoding_string = "ASCII";
3811 break;
50842bdc 3812 case BT_STRING_ENCODING_UTF8:
273b65be
JG		 3813 encoding_string = "UTF8";
3814 break;
3815 default:
3816 encoding_string = "unknown";
3817 break;
3818 }
3819
3820 return encoding_string;
3821}
3822
3823static
50842bdc 3824const char *get_integer_base_string(enum bt_integer_base base)
273b65be
JG		 3825{
3826 const char *base_string;
3827
3828 switch (base) {
50842bdc
PP		 3829 case BT_INTEGER_BASE_DECIMAL:
3830 case BT_INTEGER_BASE_UNSPECIFIED:
273b65be
JG		 3831 base_string = "decimal";
3832 break;
50842bdc 3833 case BT_INTEGER_BASE_HEXADECIMAL:
273b65be
JG		 3834 base_string = "hexadecimal";
3835 break;
50842bdc 3836 case BT_INTEGER_BASE_OCTAL:
273b65be
JG		 3837 base_string = "octal";
3838 break;
50842bdc 3839 case BT_INTEGER_BASE_BINARY:
273b65be
JG		 3840 base_string = "binary";
3841 break;
3842 default:
3843 base_string = "unknown";
3844 break;
3845 }
3846
3847 return base_string;
3848}
3849
6acddae3 3850static
27e326eb 3851void append_field_name(struct metadata_context *context,
6acddae3
PP		 3852 const char *name)
3853{
3854 g_string_append_c(context->string, ' ');
3855
f4cc9a21 3856 if (!bt_identifier_is_valid(name) || *name == '_') {
6acddae3
PP		 3857 g_string_append_c(context->string, '_');
3858 }
3859
3860 g_string_append(context->string, name);
3861}
3862
273b65be 3863static
50842bdc 3864int bt_field_type_integer_serialize(struct bt_field_type *type,
273b65be
JG		 3865 struct metadata_context *context)
3866{
50842bdc
PP		 3867 struct bt_field_type_integer *integer = container_of(type,
3868 struct bt_field_type_integer, parent);
6cfb906f 3869 int ret = 0;
273b65be 3870
4e8304f7
PP		 3871 BT_LOGD("Serializing integer field type's metadata: "
3872 "ft-addr=%p, metadata-context-addr=%p", type, context);
273b65be 3873 g_string_append_printf(context->string,
dc3fffef
PP		 3874 "integer { size = %u; align = %u; signed = %s; encoding = %s; base = %s; byte_order = %s",
3875 integer->size, type->alignment,
3876 (integer->is_signed ? "true" : "false"),
3877 get_encoding_string(integer->encoding),
3878 get_integer_base_string(integer->base),
3879 get_byte_order_string(integer->user_byte_order));
6cfb906f 3880 if (integer->mapped_clock) {
50842bdc 3881 const char *clock_name = bt_clock_class_get_name(
6cfb906f
JG		 3882 integer->mapped_clock);
3883
4e8304f7 3884 assert(clock_name);
6cfb906f 3885 g_string_append_printf(context->string,
4ebdec03 3886 "; map = clock.%s.value", clock_name);
6cfb906f
JG		 3887 }
3888
3889 g_string_append(context->string, "; }");
6cfb906f 3890 return ret;
273b65be
JG		 3891}
3892
3893static
50842bdc 3894int bt_field_type_enumeration_serialize(struct bt_field_type *type,
273b65be
JG		 3895 struct metadata_context *context)
3896{
3897 size_t entry;
9ce21c30 3898 int ret;
50842bdc
PP		 3899 struct bt_field_type_enumeration *enumeration = container_of(type,
3900 struct bt_field_type_enumeration, parent);
3901 struct bt_field_type *container_type;
b92ddaaa 3902 int container_signed;
273b65be 3903
4e8304f7
PP		 3904 BT_LOGD("Serializing enumeration field type's metadata: "
3905 "ft-addr=%p, metadata-context-addr=%p", type, context);
50842bdc 3906 container_type = bt_field_type_enumeration_get_container_type(type);
4e8304f7 3907 assert(container_type);
b92ddaaa 3908 container_signed = bt_ctf_field_type_integer_get_signed(container_type);
4e8304f7 3909 assert(container_signed >= 0);
273b65be 3910 g_string_append(context->string, "enum : ");
ec159b1e 3911 BT_LOGD_STR("Serializing enumeration field type's container field type's metadata.");
50842bdc 3912 ret = bt_field_type_serialize(enumeration->container, context);
273b65be 3913 if (ret) {
4e8304f7
PP		 3914 BT_LOGW("Cannot serialize enumeration field type's container field type's metadata: "
3915 "container-ft-addr=%p", enumeration->container);
3916 goto end;
273b65be
JG		 3917 }
3918
3919 g_string_append(context->string, " { ");
3920 for (entry = 0; entry < enumeration->entries->len; entry++) {
3921 struct enumeration_mapping *mapping =
3922 enumeration->entries->pdata[entry];
f4cc9a21
PP		 3923 const char *label = g_quark_to_string(mapping->string);
3924
3925 g_string_append(context->string, "\"");
3926
3927 if (!bt_identifier_is_valid(label) || label[0] == '_') {
3928 g_string_append(context->string, "_");
3929 }
3930
3931 g_string_append_printf(context->string, "%s\" = ", label);
273b65be 3932
b92ddaaa
JG		 3933 if (container_signed) {
3934 if (mapping->range_start._signed ==
3935 mapping->range_end._signed) {
3936 g_string_append_printf(context->string,
f4cc9a21 3937 "%" PRId64,
b92ddaaa
JG		 3938 mapping->range_start._signed);
3939 } else {
3940 g_string_append_printf(context->string,
f4cc9a21 3941 "%" PRId64 " ... %" PRId64,
b92ddaaa
JG		 3942 mapping->range_start._signed,
3943 mapping->range_end._signed);
3944 }
273b65be 3945 } else {
b92ddaaa
JG		 3946 if (mapping->range_start._unsigned ==
3947 mapping->range_end._unsigned) {
3948 g_string_append_printf(context->string,
f4cc9a21 3949 "%" PRIu64,
b92ddaaa
JG		 3950 mapping->range_start._unsigned);
3951 } else {
3952 g_string_append_printf(context->string,
f4cc9a21 3953 "%" PRIu64 " ... %" PRIu64,
b92ddaaa
JG		 3954 mapping->range_start._unsigned,
3955 mapping->range_end._unsigned);
3956 }
273b65be
JG		 3957 }
3958
3959 g_string_append(context->string,
3960 ((entry != (enumeration->entries->len - 1)) ?
3961 ", " : " }"));
3962 }
3963
3964 if (context->field_name->len) {
27e326eb 3965 append_field_name(context,
273b65be
JG		 3966 context->field_name->str);
3967 g_string_assign(context->field_name, "");
3968 }
3969end:
4e8304f7 3970 bt_put(container_type);
273b65be
JG		 3971 return ret;
3972}
3973
3974static
50842bdc 3975int bt_field_type_floating_point_serialize(struct bt_field_type *type,
273b65be
JG		 3976 struct metadata_context *context)
3977{
50842bdc
PP		 3978 struct bt_field_type_floating_point *floating_point = container_of(
3979 type, struct bt_field_type_floating_point, parent);
273b65be 3980
4e8304f7
PP		 3981 BT_LOGD("Serializing floating point number field type's metadata: "
3982 "ft-addr=%p, metadata-context-addr=%p", type, context);
273b65be 3983 g_string_append_printf(context->string,
dc3fffef
PP		 3984 "floating_point { exp_dig = %u; mant_dig = %u; byte_order = %s; align = %u; }",
3985 floating_point->exp_dig,
3986 floating_point->mant_dig,
3987 get_byte_order_string(floating_point->user_byte_order),
3988 type->alignment);
273b65be
JG		 3989 return 0;
3990}
3991
3992static
50842bdc 3993int bt_field_type_structure_serialize(struct bt_field_type *type,
273b65be
JG		 3994 struct metadata_context *context)
3995{
3996 size_t i;
3997 unsigned int indent;
5286528d 3998 int ret = 0;
50842bdc
PP		 3999 struct bt_field_type_structure *structure = container_of(type,
4000 struct bt_field_type_structure, parent);
273b65be
JG		 4001 GString *structure_field_name = context->field_name;
4002
4e8304f7
PP		 4003 BT_LOGD("Serializing structure field type's metadata: "
4004 "ft-addr=%p, metadata-context-addr=%p", type, context);
273b65be
JG		 4005 context->field_name = g_string_new("");
4006
4007 context->current_indentation_level++;
4008 g_string_append(context->string, "struct {\n");
4009
4010 for (i = 0; i < structure->fields->len; i++) {
dfc1504d
PP		 4011 struct structure_field *field = structure->fields->pdata[i];
4012
ec159b1e 4013 BT_LOGD("Serializing structure field type's field metadata: "
1974687e 4014 "index=%zu, "
dfc1504d
PP		 4015 "field-ft-addr=%p, field-name=\"%s\"",
4016 i, field, g_quark_to_string(field->name));
273b65be
JG		 4017
4018 for (indent = 0; indent < context->current_indentation_level;
4019 indent++) {
4020 g_string_append_c(context->string, '\t');
4021 }
4022
273b65be
JG		 4023 g_string_assign(context->field_name,
4024 g_quark_to_string(field->name));
50842bdc 4025 ret = bt_field_type_serialize(field->type, context);
273b65be 4026 if (ret) {
4e8304f7 4027 BT_LOGW("Cannot serialize structure field type's field's metadata: "
1974687e 4028 "index=%zu, "
4e8304f7
PP		 4029 "field-ft-addr=%p, field-name=\"%s\"",
4030 i, field->type,
4031 g_quark_to_string(field->name));
273b65be
JG		 4032 goto end;
4033 }
4034
4035 if (context->field_name->len) {
27e326eb 4036 append_field_name(context,
273b65be
JG		 4037 context->field_name->str);
4038 }
4039 g_string_append(context->string, ";\n");
4040 }
4041
4042 context->current_indentation_level--;
4043 for (indent = 0; indent < context->current_indentation_level;
4044 indent++) {
4045 g_string_append_c(context->string, '\t');
4046 }
4047
dc3fffef
PP		 4048 g_string_append_printf(context->string, "} align(%u)",
4049 type->alignment);
273b65be
JG		 4050end:
4051 g_string_free(context->field_name, TRUE);
4052 context->field_name = structure_field_name;
4053 return ret;
4054}
4055
4056static
50842bdc 4057int bt_field_type_variant_serialize(struct bt_field_type *type,
273b65be
JG		 4058 struct metadata_context *context)
4059{
4060 size_t i;
4061 unsigned int indent;
4062 int ret = 0;
50842bdc
PP		 4063 struct bt_field_type_variant *variant = container_of(
4064 type, struct bt_field_type_variant, parent);
273b65be
JG		 4065 GString *variant_field_name = context->field_name;
4066
4e8304f7
PP		 4067 BT_LOGD("Serializing variant field type's metadata: "
4068 "ft-addr=%p, metadata-context-addr=%p", type, context);
273b65be 4069 context->field_name = g_string_new("");
6964b7fd 4070 if (variant->tag_name->len > 0) {
27e326eb
JG		 4071 g_string_append(context->string, "variant <");
4072 append_field_name(context, variant->tag_name->str);
4073 g_string_append(context->string, "> {\n");
6964b7fd
JG		 4074 } else {
4075 g_string_append(context->string, "variant {\n");
4076 }
4077
273b65be
JG		 4078 context->current_indentation_level++;
4079 for (i = 0; i < variant->fields->len; i++) {
4080 struct structure_field *field = variant->fields->pdata[i];
4081
ec159b1e 4082 BT_LOGD("Serializing variant field type's field metadata: "
1974687e 4083 "index=%zu, "
dfc1504d
PP		 4084 "field-ft-addr=%p, field-name=\"%s\"",
4085 i, field, g_quark_to_string(field->name));
4086
273b65be
JG		 4087 g_string_assign(context->field_name,
4088 g_quark_to_string(field->name));
4089 for (indent = 0; indent < context->current_indentation_level;
4090 indent++) {
4091 g_string_append_c(context->string, '\t');
4092 }
4093
4094 g_string_assign(context->field_name,
4095 g_quark_to_string(field->name));
50842bdc 4096 ret = bt_field_type_serialize(field->type, context);
273b65be 4097 if (ret) {
4e8304f7 4098 BT_LOGW("Cannot serialize variant field type's field's metadata: "
1974687e 4099 "index=%zu, "
4e8304f7
PP		 4100 "field-ft-addr=%p, field-name=\"%s\"",
4101 i, field->type,
4102 g_quark_to_string(field->name));
273b65be
JG		 4103 goto end;
4104 }
4105
4106 if (context->field_name->len) {
27e326eb 4107 append_field_name(context,
273b65be 4108 context->field_name->str);
6acddae3 4109 g_string_append_c(context->string, ';');
273b65be
JG		 4110 }
4111
4112 g_string_append_c(context->string, '\n');
4113 }
4114
4115 context->current_indentation_level--;
4116 for (indent = 0; indent < context->current_indentation_level;
4117 indent++) {
4118 g_string_append_c(context->string, '\t');
4119 }
4120
4121 g_string_append(context->string, "}");
4122end:
4123 g_string_free(context->field_name, TRUE);
4124 context->field_name = variant_field_name;
4125 return ret;
4126}
4127
4128static
50842bdc 4129int bt_field_type_array_serialize(struct bt_field_type *type,
273b65be
JG		 4130 struct metadata_context *context)
4131{
4132 int ret = 0;
50842bdc
PP		 4133 struct bt_field_type_array *array = container_of(type,
4134 struct bt_field_type_array, parent);
273b65be 4135
4e8304f7
PP		 4136 BT_LOGD("Serializing array field type's metadata: "
4137 "ft-addr=%p, metadata-context-addr=%p", type, context);
ec159b1e 4138 BT_LOGD_STR("Serializing array field type's element field type's metadata.");
50842bdc 4139 ret = bt_field_type_serialize(array->element_type, context);
273b65be 4140 if (ret) {
4e8304f7
PP		 4141 BT_LOGW("Cannot serialize array field type's element field type's metadata: "
4142 "element-ft-addr=%p", array->element_type);
273b65be
JG		 4143 goto end;
4144 }
4145
4146 if (context->field_name->len) {
27e326eb 4147 append_field_name(context,
6acddae3
PP		 4148 context->field_name->str);
4149
4150 g_string_append_printf(context->string, "[%u]", array->length);
273b65be
JG		 4151 g_string_assign(context->field_name, "");
4152 } else {
4153 g_string_append_printf(context->string, "[%u]", array->length);
4154 }
4155end:
4156 return ret;
4157}
4158
4159static
50842bdc 4160int bt_field_type_sequence_serialize(struct bt_field_type *type,
273b65be
JG		 4161 struct metadata_context *context)
4162{
4163 int ret = 0;
50842bdc
PP		 4164 struct bt_field_type_sequence *sequence = container_of(
4165 type, struct bt_field_type_sequence, parent);
273b65be 4166
4e8304f7
PP		 4167 BT_LOGD("Serializing sequence field type's metadata: "
4168 "ft-addr=%p, metadata-context-addr=%p", type, context);
ec159b1e 4169 BT_LOGD_STR("Serializing sequence field type's element field type's metadata.");
50842bdc 4170 ret = bt_field_type_serialize(sequence->element_type, context);
273b65be 4171 if (ret) {
4e8304f7
PP		 4172 BT_LOGW("Cannot serialize sequence field type's element field type's metadata: "
4173 "element-ft-addr=%p", sequence->element_type);
273b65be
JG		 4174 goto end;
4175 }
4176
4177 if (context->field_name->len) {
27e326eb 4178 append_field_name(context, context->field_name->str);
273b65be 4179 g_string_assign(context->field_name, "");
273b65be 4180 }
27e326eb
JG		 4181 g_string_append(context->string, "[");
4182 append_field_name(context, sequence->length_field_name->str);
4183 g_string_append(context->string, "]");
273b65be
JG		 4184end:
4185 return ret;
4186}
4187
4188static
50842bdc 4189int bt_field_type_string_serialize(struct bt_field_type *type,
273b65be
JG		 4190 struct metadata_context *context)
4191{
50842bdc
PP		 4192 struct bt_field_type_string *string = container_of(
4193 type, struct bt_field_type_string, parent);
273b65be 4194
4e8304f7
PP		 4195 BT_LOGD("Serializing string field type's metadata: "
4196 "ft-addr=%p, metadata-context-addr=%p", type, context);
273b65be
JG		 4197 g_string_append_printf(context->string,
4198 "string { encoding = %s; }",
dc3fffef 4199 get_encoding_string(string->encoding));
273b65be
JG		 4200 return 0;
4201}
4202
4203static
50842bdc
PP		 4204void bt_field_type_integer_set_byte_order(struct bt_field_type *type,
4205 enum bt_byte_order byte_order)
273b65be 4206{
50842bdc
PP		 4207 struct bt_field_type_integer *integer_type = container_of(type,
4208 struct bt_field_type_integer, parent);
273b65be 4209
dc3fffef 4210 integer_type->user_byte_order = byte_order;
c35a1669
JG		 4211}
4212
4213static
50842bdc
PP		 4214void bt_field_type_enumeration_set_byte_order(
4215 struct bt_field_type *type, enum bt_byte_order byte_order)
c35a1669 4216{
50842bdc
PP		 4217 struct bt_field_type_enumeration *enum_type = container_of(type,
4218 struct bt_field_type_enumeration, parent);
c35a1669
JG		 4219
4220 /* Safe to assume that container is an integer */
50842bdc 4221 bt_field_type_integer_set_byte_order(enum_type->container,
dc3fffef 4222 byte_order);
273b65be
JG		 4223}
4224
4225static
50842bdc
PP		 4226void bt_field_type_floating_point_set_byte_order(
4227 struct bt_field_type *type, enum bt_byte_order byte_order)
273b65be 4228{
50842bdc
PP		 4229 struct bt_field_type_floating_point *floating_point_type =
4230 container_of(type, struct bt_field_type_floating_point,
273b65be
JG		 4231 parent);
4232
dc3fffef 4233 floating_point_type->user_byte_order = byte_order;
c35a1669
JG		 4234}
4235
4236static
50842bdc
PP		 4237void bt_field_type_structure_set_byte_order(struct bt_field_type *type,
4238 enum bt_byte_order byte_order)
c35a1669
JG		 4239{
4240 int i;
50842bdc
PP		 4241 struct bt_field_type_structure *structure_type =
4242 container_of(type, struct bt_field_type_structure,
c35a1669
JG		 4243 parent);
4244
4245 for (i = 0; i < structure_type->fields->len; i++) {
4246 struct structure_field *field = g_ptr_array_index(
4247 structure_type->fields, i);
50842bdc 4248 struct bt_field_type *field_type = field->type;
c35a1669 4249
dc3fffef
PP		 4250 if (set_byte_order_funcs[field_type->id]) {
4251 set_byte_order_funcs[field_type->id](
4252 field_type, byte_order);
c35a1669
JG		 4253 }
4254 }
4255}
4256
4257static
50842bdc
PP		 4258void bt_field_type_variant_set_byte_order(struct bt_field_type *type,
4259 enum bt_byte_order byte_order)
c35a1669
JG		 4260{
4261 int i;
50842bdc
PP		 4262 struct bt_field_type_variant *variant_type =
4263 container_of(type, struct bt_field_type_variant,
c35a1669
JG		 4264 parent);
4265
4266 for (i = 0; i < variant_type->fields->len; i++) {
4267 struct structure_field *field = g_ptr_array_index(
4268 variant_type->fields, i);
50842bdc 4269 struct bt_field_type *field_type = field->type;
c35a1669 4270
dc3fffef
PP		 4271 if (set_byte_order_funcs[field_type->id]) {
4272 set_byte_order_funcs[field_type->id](
4273 field_type, byte_order);
c35a1669
JG		 4274 }
4275 }
4276}
4277
4278static
50842bdc
PP		 4279void bt_field_type_array_set_byte_order(struct bt_field_type *type,
4280 enum bt_byte_order byte_order)
c35a1669 4281{
50842bdc
PP		 4282 struct bt_field_type_array *array_type =
4283 container_of(type, struct bt_field_type_array,
c35a1669
JG		 4284 parent);
4285
dc3fffef
PP		 4286 if (set_byte_order_funcs[array_type->element_type->id]) {
4287 set_byte_order_funcs[array_type->element_type->id](
4288 array_type->element_type, byte_order);
c35a1669
JG		 4289 }
4290}
4291
4292static
50842bdc
PP		 4293void bt_field_type_sequence_set_byte_order(struct bt_field_type *type,
4294 enum bt_byte_order byte_order)
c35a1669 4295{
50842bdc
PP		 4296 struct bt_field_type_sequence *sequence_type =
4297 container_of(type, struct bt_field_type_sequence,
c35a1669
JG		 4298 parent);
4299
4300 if (set_byte_order_funcs[
dc3fffef 4301 sequence_type->element_type->id]) {
c35a1669 4302 set_byte_order_funcs[
dc3fffef
PP		 4303 sequence_type->element_type->id](
4304 sequence_type->element_type, byte_order);
c35a1669 4305 }
273b65be 4306}
24724933
JG		 4307
4308static
50842bdc
PP		 4309struct bt_field_type *bt_field_type_integer_copy(
4310 struct bt_field_type *type)
24724933 4311{
50842bdc
PP		 4312 struct bt_field_type *copy;
4313 struct bt_field_type_integer *integer, *copy_integer;
24724933 4314
4e8304f7 4315 BT_LOGD("Copying integer field type's: addr=%p", type);
50842bdc
PP		 4316 integer = container_of(type, struct bt_field_type_integer, parent);
4317 copy = bt_field_type_integer_create(integer->size);
24724933 4318 if (!copy) {
4e8304f7 4319 BT_LOGE_STR("Cannot create integer field type.");
24724933
JG		 4320 goto end;
4321 }
4322
50842bdc 4323 copy_integer = container_of(copy, struct bt_field_type_integer,
24724933 4324 parent);
dc3fffef 4325 copy_integer->mapped_clock = bt_get(integer->mapped_clock);
445c3471 4326 copy_integer->user_byte_order = integer->user_byte_order;
dc3fffef
PP		 4327 copy_integer->is_signed = integer->is_signed;
4328 copy_integer->size = integer->size;
4329 copy_integer->base = integer->base;
4330 copy_integer->encoding = integer->encoding;
4e8304f7
PP		 4331 BT_LOGD("Copied integer field type: original-ft-addr=%p, copy-ft-addr=%p",
4332 type, copy);
445c3471 4333
24724933
JG		 4334end:
4335 return copy;
4336}
4337
4338static
50842bdc
PP		 4339struct bt_field_type *bt_field_type_enumeration_copy(
4340 struct bt_field_type *type)
24724933
JG		 4341{
4342 size_t i;
50842bdc
PP		 4343 struct bt_field_type *copy = NULL, *copy_container;
4344 struct bt_field_type_enumeration *enumeration, *copy_enumeration;
24724933 4345
4e8304f7 4346 BT_LOGD("Copying enumeration field type's: addr=%p", type);
50842bdc 4347 enumeration = container_of(type, struct bt_field_type_enumeration,
24724933
JG		 4348 parent);
4349
4350 /* Copy the source enumeration's container */
ec159b1e 4351 BT_LOGD_STR("Copying enumeration field type's container field type.");
50842bdc 4352 copy_container = bt_field_type_copy(enumeration->container);
24724933 4353 if (!copy_container) {
4e8304f7 4354 BT_LOGE_STR("Cannot copy enumeration field type's container field type.");
24724933
JG		 4355 goto end;
4356 }
4357
50842bdc 4358 copy = bt_field_type_enumeration_create(copy_container);
24724933 4359 if (!copy) {
4e8304f7 4360 BT_LOGE_STR("Cannot create enumeration field type.");
24724933
JG		 4361 goto end;
4362 }
4363 copy_enumeration = container_of(copy,
50842bdc 4364 struct bt_field_type_enumeration, parent);
24724933
JG		 4365
4366 /* Copy all enumaration entries */
4367 for (i = 0; i < enumeration->entries->len; i++) {
4368 struct enumeration_mapping *mapping = g_ptr_array_index(
4369 enumeration->entries, i);
96e8f959 4370 struct enumeration_mapping *copy_mapping = g_new0(
24724933
JG		 4371 struct enumeration_mapping, 1);
4372
4373 if (!copy_mapping) {
4e8304f7 4374 BT_LOGE_STR("Failed to allocate one enumeration mapping.");
24724933
JG		 4375 goto error;
4376 }
4377
4378 *copy_mapping = *mapping;
4379 g_ptr_array_add(copy_enumeration->entries, copy_mapping);
4380 }
4381
4e8304f7
PP		 4382 BT_LOGD("Copied enumeration field type: original-ft-addr=%p, copy-ft-addr=%p",
4383 type, copy);
4384
24724933 4385end:
83509119 4386 bt_put(copy_container);
24724933
JG		 4387 return copy;
4388error:
83509119
JG		 4389 bt_put(copy_container);
4390 BT_PUT(copy);
4391 return copy;
24724933
JG		 4392}
4393
4394static
50842bdc
PP		 4395struct bt_field_type *bt_field_type_floating_point_copy(
4396 struct bt_field_type *type)
24724933 4397{
50842bdc
PP		 4398 struct bt_field_type *copy;
4399 struct bt_field_type_floating_point *floating_point, *copy_float;
24724933 4400
4e8304f7 4401 BT_LOGD("Copying floating point number field type's: addr=%p", type);
24724933 4402 floating_point = container_of(type,
50842bdc
PP		 4403 struct bt_field_type_floating_point, parent);
4404 copy = bt_field_type_floating_point_create();
24724933 4405 if (!copy) {
4e8304f7 4406 BT_LOGE_STR("Cannot create floating point number field type.");
24724933
JG		 4407 goto end;
4408 }
4409
4410 copy_float = container_of(copy,
50842bdc 4411 struct bt_field_type_floating_point, parent);
445c3471 4412 copy_float->user_byte_order = floating_point->user_byte_order;
dc3fffef
PP		 4413 copy_float->exp_dig = floating_point->exp_dig;
4414 copy_float->mant_dig = floating_point->mant_dig;
4e8304f7
PP		 4415 BT_LOGD("Copied floating point number field type: original-ft-addr=%p, copy-ft-addr=%p",
4416 type, copy);
24724933
JG		 4417end:
4418 return copy;
4419}
4420
4421static
50842bdc
PP		 4422struct bt_field_type *bt_field_type_structure_copy(
4423 struct bt_field_type *type)
24724933 4424{
4e8304f7 4425 int64_t i;
24724933
JG		 4426 GHashTableIter iter;
4427 gpointer key, value;
50842bdc
PP		 4428 struct bt_field_type *copy;
4429 struct bt_field_type_structure *structure, *copy_structure;
24724933 4430
4e8304f7 4431 BT_LOGD("Copying structure field type's: addr=%p", type);
50842bdc 4432 structure = container_of(type, struct bt_field_type_structure,
24724933 4433 parent);
50842bdc 4434 copy = bt_field_type_structure_create();
24724933 4435 if (!copy) {
4e8304f7 4436 BT_LOGE_STR("Cannot create structure field type.");
24724933
JG		 4437 goto end;
4438 }
4439
4440 copy_structure = container_of(copy,
50842bdc 4441 struct bt_field_type_structure, parent);
24724933
JG		 4442
4443 /* Copy field_name_to_index */
4444 g_hash_table_iter_init(&iter, structure->field_name_to_index);
4445 while (g_hash_table_iter_next (&iter, &key, &value)) {
4446 g_hash_table_insert(copy_structure->field_name_to_index,
4447 key, value);
4448 }
4449
4450 for (i = 0; i < structure->fields->len; i++) {
4451 struct structure_field *entry, *copy_entry;
50842bdc 4452 struct bt_field_type *copy_field;
24724933 4453
dfc1504d 4454 entry = g_ptr_array_index(structure->fields, i);
ec159b1e 4455 BT_LOGD("Copying structure field type's field: "
dfc1504d
PP		 4456 "index=%" PRId64 ", "
4457 "field-ft-addr=%p, field-name=\"%s\"",
4458 i, entry, g_quark_to_string(entry->name));
24724933
JG		 4459 copy_entry = g_new0(struct structure_field, 1);
4460 if (!copy_entry) {
4e8304f7 4461 BT_LOGE_STR("Failed to allocate one structure field type field.");
24724933
JG		 4462 goto error;
4463 }
4464
50842bdc 4465 copy_field = bt_field_type_copy(entry->type);
24724933 4466 if (!copy_field) {
4e8304f7
PP		 4467 BT_LOGE("Cannot copy structure field type's field: "
4468 "index=%" PRId64 ", "
4469 "field-ft-addr=%p, field-name=\"%s\"",
4470 i, entry, g_quark_to_string(entry->name));
24724933
JG		 4471 g_free(copy_entry);
4472 goto error;
4473 }
4474
4475 copy_entry->name = entry->name;
4476 copy_entry->type = copy_field;
4477 g_ptr_array_add(copy_structure->fields, copy_entry);
4478 }
4479
4e8304f7
PP		 4480 BT_LOGD("Copied structure field type: original-ft-addr=%p, copy-ft-addr=%p",
4481 type, copy);
4482
24724933
JG		 4483end:
4484 return copy;
4485error:
83509119
JG		 4486 BT_PUT(copy);
4487 return copy;
24724933
JG		 4488}
4489
4490static
50842bdc
PP		 4491struct bt_field_type *bt_field_type_variant_copy(
4492 struct bt_field_type *type)
24724933 4493{
4e8304f7 4494 int64_t i;
24724933
JG		 4495 GHashTableIter iter;
4496 gpointer key, value;
50842bdc
PP		 4497 struct bt_field_type *copy = NULL, *copy_tag = NULL;
4498 struct bt_field_type_variant *variant, *copy_variant;
24724933 4499
4e8304f7 4500 BT_LOGD("Copying variant field type's: addr=%p", type);
50842bdc 4501 variant = container_of(type, struct bt_field_type_variant,
24724933
JG		 4502 parent);
4503 if (variant->tag) {
ec159b1e 4504 BT_LOGD_STR("Copying variant field type's tag field type.");
50842bdc 4505 copy_tag = bt_field_type_copy(&variant->tag->parent);
24724933 4506 if (!copy_tag) {
4e8304f7 4507 BT_LOGE_STR("Cannot copy variant field type's tag field type.");
24724933
JG		 4508 goto end;
4509 }
4510 }
4511
50842bdc 4512 copy = bt_field_type_variant_create(copy_tag,
24724933
JG		 4513 variant->tag_name->len ? variant->tag_name->str : NULL);
4514 if (!copy) {
4e8304f7 4515 BT_LOGE_STR("Cannot create variant field type.");
24724933
JG		 4516 goto end;
4517 }
4518
50842bdc 4519 copy_variant = container_of(copy, struct bt_field_type_variant,
24724933
JG		 4520 parent);
4521
4522 /* Copy field_name_to_index */
4523 g_hash_table_iter_init(&iter, variant->field_name_to_index);
4524 while (g_hash_table_iter_next (&iter, &key, &value)) {
4525 g_hash_table_insert(copy_variant->field_name_to_index,
4526 key, value);
4527 }
4528
4529 for (i = 0; i < variant->fields->len; i++) {
4530 struct structure_field *entry, *copy_entry;
50842bdc 4531 struct bt_field_type *copy_field;
24724933 4532
dfc1504d 4533 entry = g_ptr_array_index(variant->fields, i);
ec159b1e 4534 BT_LOGD("Copying variant field type's field: "
dfc1504d
PP		 4535 "index=%" PRId64 ", "
4536 "field-ft-addr=%p, field-name=\"%s\"",
4537 i, entry, g_quark_to_string(entry->name));
24724933
JG		 4538 copy_entry = g_new0(struct structure_field, 1);
4539 if (!copy_entry) {
4e8304f7 4540 BT_LOGE_STR("Failed to allocate one variant field type field.");
24724933
JG		 4541 goto error;
4542 }
4543
50842bdc 4544 copy_field = bt_field_type_copy(entry->type);
24724933 4545 if (!copy_field) {
4e8304f7
PP		 4546 BT_LOGE("Cannot copy variant field type's field: "
4547 "index=%" PRId64 ", "
4548 "field-ft-addr=%p, field-name=\"%s\"",
4549 i, entry, g_quark_to_string(entry->name));
24724933
JG		 4550 g_free(copy_entry);
4551 goto error;
4552 }
4553
4554 copy_entry->name = entry->name;
4555 copy_entry->type = copy_field;
4556 g_ptr_array_add(copy_variant->fields, copy_entry);
4557 }
4558
b011f6b0 4559 if (variant->tag_field_path) {
ec159b1e 4560 BT_LOGD_STR("Copying variant field type's tag field path.");
50842bdc 4561 copy_variant->tag_field_path = bt_field_path_copy(
b011f6b0
PP		 4562 variant->tag_field_path);
4563 if (!copy_variant->tag_field_path) {
4e8304f7 4564 BT_LOGE_STR("Cannot copy variant field type's tag field path.");
4a1e8671
JG		 4565 goto error;
4566 }
4567 }
4e8304f7
PP		 4568
4569 BT_LOGD("Copied variant field type: original-ft-addr=%p, copy-ft-addr=%p",
4570 type, copy);
4571
24724933 4572end:
83509119 4573 bt_put(copy_tag);
24724933
JG		 4574 return copy;
4575error:
83509119
JG		 4576 bt_put(copy_tag);
4577 BT_PUT(copy);
4578 return copy;
24724933
JG		 4579}
4580
4581static
50842bdc
PP		 4582struct bt_field_type *bt_field_type_array_copy(
4583 struct bt_field_type *type)
24724933 4584{
50842bdc
PP		 4585 struct bt_field_type *copy = NULL, *copy_element;
4586 struct bt_field_type_array *array;
24724933 4587
4e8304f7 4588 BT_LOGD("Copying array field type's: addr=%p", type);
50842bdc 4589 array = container_of(type, struct bt_field_type_array,
24724933 4590 parent);
ec159b1e 4591 BT_LOGD_STR("Copying array field type's element field type.");
50842bdc 4592 copy_element = bt_field_type_copy(array->element_type);
24724933 4593 if (!copy_element) {
4e8304f7 4594 BT_LOGE_STR("Cannot copy array field type's element field type.");
24724933
JG		 4595 goto end;
4596 }
4597
50842bdc 4598 copy = bt_field_type_array_create(copy_element, array->length);
24724933 4599 if (!copy) {
4e8304f7 4600 BT_LOGE_STR("Cannot create array field type.");
24724933
JG		 4601 goto end;
4602 }
4e8304f7
PP		 4603
4604 BT_LOGD("Copied array field type: original-ft-addr=%p, copy-ft-addr=%p",
4605 type, copy);
4606
24724933 4607end:
83509119 4608 bt_put(copy_element);
24724933
JG		 4609 return copy;
4610}
4611
4612static
50842bdc
PP		 4613struct bt_field_type *bt_field_type_sequence_copy(
4614 struct bt_field_type *type)
24724933 4615{
50842bdc
PP		 4616 struct bt_field_type *copy = NULL, *copy_element;
4617 struct bt_field_type_sequence *sequence, *copy_sequence;
24724933 4618
4e8304f7 4619 BT_LOGD("Copying sequence field type's: addr=%p", type);
50842bdc 4620 sequence = container_of(type, struct bt_field_type_sequence,
24724933 4621 parent);
ec159b1e 4622 BT_LOGD_STR("Copying sequence field type's element field type.");
50842bdc 4623 copy_element = bt_field_type_copy(sequence->element_type);
24724933 4624 if (!copy_element) {
4e8304f7 4625 BT_LOGE_STR("Cannot copy sequence field type's element field type.");
24724933
JG		 4626 goto end;
4627 }
4628
50842bdc 4629 copy = bt_field_type_sequence_create(copy_element,
24724933
JG		 4630 sequence->length_field_name->len ?
4631 sequence->length_field_name->str : NULL);
4632 if (!copy) {
4e8304f7 4633 BT_LOGE_STR("Cannot create sequence field type.");
24724933
JG		 4634 goto end;
4635 }
4636
50842bdc 4637 copy_sequence = container_of(copy, struct bt_field_type_sequence,
24724933 4638 parent);
aa4e271c 4639 if (sequence->length_field_path) {
ec159b1e 4640 BT_LOGD_STR("Copying sequence field type's length field path.");
50842bdc 4641 copy_sequence->length_field_path = bt_field_path_copy(
aa4e271c
JG		 4642 sequence->length_field_path);
4643 if (!copy_sequence->length_field_path) {
4e8304f7 4644 BT_LOGE_STR("Cannot copy sequence field type's length field path.");
aa4e271c
JG		 4645 goto error;
4646 }
4647 }
4e8304f7
PP		 4648
4649 BT_LOGD("Copied sequence field type: original-ft-addr=%p, copy-ft-addr=%p",
4650 type, copy);
4651
24724933 4652end:
83509119 4653 bt_put(copy_element);
24724933 4654 return copy;
aa4e271c 4655error:
83509119 4656 BT_PUT(copy);
aa4e271c 4657 goto end;
24724933
JG		 4658}
4659
4660static
50842bdc
PP		 4661struct bt_field_type *bt_field_type_string_copy(
4662 struct bt_field_type *type)
24724933 4663{
50842bdc 4664 struct bt_field_type *copy;
24724933 4665
4e8304f7 4666 BT_LOGD("Copying string field type's: addr=%p", type);
50842bdc 4667 copy = bt_field_type_string_create();
24724933 4668 if (!copy) {
4e8304f7 4669 BT_LOGE_STR("Cannot create string field type.");
24724933
JG		 4670 goto end;
4671 }
4672
4e8304f7
PP		 4673 BT_LOGD("Copied string field type: original-ft-addr=%p, copy-ft-addr=%p",
4674 type, copy);
24724933
JG		 4675end:
4676 return copy;
4677}
265e809c
PP		 4678
4679static
50842bdc
PP		 4680int bt_field_type_integer_compare(struct bt_field_type *type_a,
4681 struct bt_field_type *type_b)
265e809c
PP		 4682{
4683 int ret = 1;
50842bdc
PP		 4684 struct bt_field_type_integer *int_type_a;
4685 struct bt_field_type_integer *int_type_b;
265e809c 4686
50842bdc 4687 int_type_a = container_of(type_a, struct bt_field_type_integer,
265e809c 4688 parent);
50842bdc 4689 int_type_b = container_of(type_b, struct bt_field_type_integer,
265e809c 4690 parent);
265e809c
PP		 4691
4692 /* Length */
dc3fffef 4693 if (int_type_a->size != int_type_b->size) {
4e8304f7
PP		 4694 BT_LOGV("Integer field types differ: different sizes: "
4695 "ft-a-size=%u, ft-b-size=%u",
4696 int_type_a->size, int_type_b->size);
265e809c
PP		 4697 goto end;
4698 }
4699
dc3fffef
PP		 4700 /* Byte order */
4701 if (int_type_a->user_byte_order != int_type_b->user_byte_order) {
4e8304f7
PP		 4702 BT_LOGV("Integer field types differ: different byte orders: "
4703 "ft-a-bo=%s, ft-b-bo=%s",
50842bdc
PP		 4704 bt_byte_order_string(int_type_a->user_byte_order),
4705 bt_byte_order_string(int_type_b->user_byte_order));
265e809c
PP		 4706 goto end;
4707 }
4708
4709 /* Signedness */
dc3fffef 4710 if (int_type_a->is_signed != int_type_b->is_signed) {
4e8304f7
PP		 4711 BT_LOGV("Integer field types differ: different signedness: "
4712 "ft-a-is-signed=%d, ft-b-is-signed=%d",
4713 int_type_a->is_signed,
4714 int_type_b->is_signed);
265e809c
PP		 4715 goto end;
4716 }
4717
4718 /* Base */
dc3fffef 4719 if (int_type_a->base != int_type_b->base) {
4e8304f7
PP		 4720 BT_LOGV("Integer field types differ: different bases: "
4721 "ft-a-base=%s, ft-b-base=%s",
50842bdc
PP		 4722 bt_integer_base_string(int_type_a->base),
4723 bt_integer_base_string(int_type_b->base));
265e809c
PP		 4724 goto end;
4725 }
4726
4727 /* Encoding */
dc3fffef 4728 if (int_type_a->encoding != int_type_b->encoding) {
4e8304f7
PP		 4729 BT_LOGV("Integer field types differ: different encodings: "
4730 "ft-a-encoding=%s, ft-b-encoding=%s",
50842bdc
PP		 4731 bt_string_encoding_string(int_type_a->encoding),
4732 bt_string_encoding_string(int_type_b->encoding));
265e809c
PP		 4733 goto end;
4734 }
4735
4736 /* Mapped clock */
dc3fffef 4737 if (int_type_a->mapped_clock != int_type_b->mapped_clock) {
4e8304f7
PP		 4738 BT_LOGV("Integer field types differ: different mapped clock classes: "
4739 "ft-a-mapped-clock-class-addr=%p, "
32e87ceb
PP		 4740 "ft-b-mapped-clock-class-addr=%p, "
4741 "ft-a-mapped-clock-class-name=\"%s\", "
4e8304f7
PP		 4742 "ft-b-mapped-clock-class-name=\"%s\"",
4743 int_type_a->mapped_clock, int_type_b->mapped_clock,
50842bdc
PP		 4744 int_type_a->mapped_clock ? bt_clock_class_get_name(int_type_a->mapped_clock) : "",
4745 int_type_b->mapped_clock ? bt_clock_class_get_name(int_type_b->mapped_clock) : "");
265e809c
PP		 4746 goto end;
4747 }
4748
4749 /* Equal */
4750 ret = 0;
4751
4752end:
4753 return ret;
4754}
4755
4756static
50842bdc
PP		 4757int bt_field_type_floating_point_compare(struct bt_field_type *type_a,
4758 struct bt_field_type *type_b)
265e809c
PP		 4759{
4760 int ret = 1;
50842bdc
PP		 4761 struct bt_field_type_floating_point *float_a;
4762 struct bt_field_type_floating_point *float_b;
265e809c
PP		 4763
4764 float_a = container_of(type_a,
50842bdc 4765 struct bt_field_type_floating_point, parent);
265e809c 4766 float_b = container_of(type_b,
50842bdc 4767 struct bt_field_type_floating_point, parent);
265e809c 4768
dc3fffef
PP		 4769 /* Byte order */
4770 if (float_a->user_byte_order != float_b->user_byte_order) {
4e8304f7
PP		 4771 BT_LOGV("Floating point number field types differ: different byte orders: "
4772 "ft-a-bo=%s, ft-b-bo=%s",
50842bdc
PP		 4773 bt_byte_order_string(float_a->user_byte_order),
4774 bt_byte_order_string(float_b->user_byte_order));
265e809c
PP		 4775 goto end;
4776 }
4777
4778 /* Exponent length */
dc3fffef 4779 if (float_a->exp_dig != float_b->exp_dig) {
4e8304f7 4780 BT_LOGV("Floating point number field types differ: different exponent sizes: "
32e87ceb 4781 "ft-a-exp-size=%u, ft-b-exp-size=%u",
4e8304f7 4782 float_a->exp_dig, float_b->exp_dig);
265e809c
PP		 4783 goto end;
4784 }
4785
4786 /* Mantissa length */
dc3fffef 4787 if (float_a->mant_dig != float_b->mant_dig) {
4e8304f7 4788 BT_LOGV("Floating point number field types differ: different mantissa sizes: "
32e87ceb 4789 "ft-a-mant-size=%u, ft-b-mant-size=%u",
4e8304f7 4790 float_a->mant_dig, float_b->mant_dig);
265e809c
PP		 4791 goto end;
4792 }
4793
4794 /* Equal */
4795 ret = 0;
4796
4797end:
4798 return ret;
4799}
4800
4801static
4802int compare_enumeration_mappings(struct enumeration_mapping *mapping_a,
4803 struct enumeration_mapping *mapping_b)
4804{
4805 int ret = 1;
4806
4807 /* Label */
4808 if (mapping_a->string != mapping_b->string) {
4e8304f7
PP		 4809 BT_LOGV("Enumeration field type mappings differ: different names: "
4810 "mapping-a-name=\"%s\", mapping-b-name=\"%s\"",
4811 g_quark_to_string(mapping_a->string),
4812 g_quark_to_string(mapping_b->string));
265e809c
PP		 4813 goto end;
4814 }
4815
4816 /* Range start */
4817 if (mapping_a->range_start._unsigned !=
4818 mapping_b->range_start._unsigned) {
4e8304f7
PP		 4819 BT_LOGV("Enumeration field type mappings differ: different starts of range: "
4820 "mapping-a-range-start-unsigned=%" PRIu64 ", "
4821 "mapping-b-range-start-unsigned=%" PRIu64,
4822 mapping_a->range_start._unsigned,
4823 mapping_b->range_start._unsigned);
265e809c
PP		 4824 goto end;
4825 }
4826
4827 /* Range end */
4828 if (mapping_a->range_end._unsigned !=
4829 mapping_b->range_end._unsigned) {
4e8304f7
PP		 4830 BT_LOGV("Enumeration field type mappings differ: different ends of range: "
4831 "mapping-a-range-end-unsigned=%" PRIu64 ", "
4832 "mapping-b-range-end-unsigned=%" PRIu64,
4833 mapping_a->range_end._unsigned,
4834 mapping_b->range_end._unsigned);
265e809c
PP		 4835 goto end;
4836 }
4837
4838 /* Equal */
4839 ret = 0;
4840
4841end:
4842 return ret;
4843}
4844
4845static
50842bdc
PP		 4846int bt_field_type_enumeration_compare(struct bt_field_type *type_a,
4847 struct bt_field_type *type_b)
265e809c
PP		 4848{
4849 int ret = 1;
4850 int i;
50842bdc
PP		 4851 struct bt_field_type_enumeration *enum_a;
4852 struct bt_field_type_enumeration *enum_b;
265e809c
PP		 4853
4854 enum_a = container_of(type_a,
50842bdc 4855 struct bt_field_type_enumeration, parent);
265e809c 4856 enum_b = container_of(type_b,
50842bdc 4857 struct bt_field_type_enumeration, parent);
265e809c
PP		 4858
4859 /* Container field type */
50842bdc 4860 ret = bt_field_type_compare(enum_a->container, enum_b->container);
265e809c 4861 if (ret) {
4e8304f7
PP		 4862 BT_LOGV("Enumeration field types differ: different container field types: "
4863 "ft-a-container-ft-addr=%p, ft-b-container-ft-addr=%p",
4864 enum_a->container, enum_b->container);
265e809c
PP		 4865 goto end;
4866 }
4867
4868 ret = 1;
4869
4870 /* Entries */
4871 if (enum_a->entries->len != enum_b->entries->len) {
4872 goto end;
4873 }
4874
4875 for (i = 0; i < enum_a->entries->len; ++i) {
4876 struct enumeration_mapping *mapping_a =
4877 g_ptr_array_index(enum_a->entries, i);
4878 struct enumeration_mapping *mapping_b =
4879 g_ptr_array_index(enum_b->entries, i);
4880
4881 if (compare_enumeration_mappings(mapping_a, mapping_b)) {
4e8304f7
PP		 4882 BT_LOGV("Enumeration field types differ: different mappings: "
4883 "ft-a-mapping-addr=%p, ft-b-mapping-addr=%p, "
4884 "ft-a-mapping-name=\"%s\", ft-b-mapping-name=\"%s\"",
4885 mapping_a, mapping_b,
4886 g_quark_to_string(mapping_a->string),
4887 g_quark_to_string(mapping_b->string));
265e809c
PP		 4888 goto end;
4889 }
4890 }
4891
4892 /* Equal */
4893 ret = 0;
4894
4895end:
4896 return ret;
4897}
4898
4899static
50842bdc
PP		 4900int bt_field_type_string_compare(struct bt_field_type *type_a,
4901 struct bt_field_type *type_b)
265e809c
PP		 4902{
4903 int ret = 1;
50842bdc
PP		 4904 struct bt_field_type_string *string_a;
4905 struct bt_field_type_string *string_b;
265e809c
PP		 4906
4907 string_a = container_of(type_a,
50842bdc 4908 struct bt_field_type_string, parent);
265e809c 4909 string_b = container_of(type_b,
50842bdc 4910 struct bt_field_type_string, parent);
265e809c
PP		 4911
4912 /* Encoding */
dc3fffef 4913 if (string_a->encoding != string_b->encoding) {
4e8304f7
PP		 4914 BT_LOGV("String field types differ: different encodings: "
4915 "ft-a-encoding=%s, ft-b-encoding=%s",
50842bdc
PP		 4916 bt_string_encoding_string(string_a->encoding),
4917 bt_string_encoding_string(string_b->encoding));
265e809c
PP		 4918 goto end;
4919 }
4920
4921 /* Equal */
4922 ret = 0;
4923
4924end:
4925 return ret;
4926}
4927
4928static
4929int compare_structure_fields(struct structure_field *field_a,
4930 struct structure_field *field_b)
4931{
4932 int ret = 1;
4933
4934 /* Label */
4935 if (field_a->name != field_b->name) {
4e8304f7
PP		 4936 BT_LOGV("Structure/variant field type fields differ: different names: "
4937 "field-a-name=%s, field-b-name=%s",
4938 g_quark_to_string(field_a->name),
4939 g_quark_to_string(field_b->name));
265e809c
PP		 4940 goto end;
4941 }
4942
4943 /* Type */
50842bdc 4944 ret = bt_field_type_compare(field_a->type, field_b->type);
4e8304f7
PP		 4945 if (ret == 1) {
4946 BT_LOGV("Structure/variant field type fields differ: different field types: "
32e87ceb 4947 "field-name=\"%s\", field-a-ft-addr=%p, field-b-ft-addr=%p",
4e8304f7
PP		 4948 g_quark_to_string(field_a->name),
4949 field_a->type, field_b->type);
4950 }
265e809c
PP		 4951
4952end:
4953 return ret;
4954}
4955
4956static
50842bdc
PP		 4957int bt_field_type_structure_compare(struct bt_field_type *type_a,
4958 struct bt_field_type *type_b)
265e809c
PP		 4959{
4960 int ret = 1;
4961 int i;
50842bdc
PP		 4962 struct bt_field_type_structure *struct_a;
4963 struct bt_field_type_structure *struct_b;
265e809c
PP		 4964
4965 struct_a = container_of(type_a,
50842bdc 4966 struct bt_field_type_structure, parent);
265e809c 4967 struct_b = container_of(type_b,
50842bdc 4968 struct bt_field_type_structure, parent);
265e809c
PP		 4969
4970 /* Alignment */
50842bdc
PP		 4971 if (bt_field_type_get_alignment(type_a) !=
4972 bt_field_type_get_alignment(type_b)) {
4e8304f7
PP		 4973 BT_LOGV("Structure field types differ: different alignments: "
4974 "ft-a-align=%u, ft-b-align=%u",
50842bdc
PP		 4975 bt_field_type_get_alignment(type_a),
4976 bt_field_type_get_alignment(type_b));
265e809c
PP		 4977 goto end;
4978 }
4979
4980 /* Fields */
4981 if (struct_a->fields->len != struct_b->fields->len) {
4e8304f7
PP		 4982 BT_LOGV("Structure field types differ: different field counts: "
4983 "ft-a-field-count=%u, ft-b-field-count=%u",
4984 struct_a->fields->len, struct_b->fields->len);
265e809c
PP		 4985 goto end;
4986 }
4987
4988 for (i = 0; i < struct_a->fields->len; ++i) {
4989 struct structure_field *field_a =
4990 g_ptr_array_index(struct_a->fields, i);
4991 struct structure_field *field_b =
4992 g_ptr_array_index(struct_b->fields, i);
4993
4994 ret = compare_structure_fields(field_a, field_b);
4995 if (ret) {
4e8304f7
PP		 4996 /* compare_structure_fields() logs what differs */
4997 BT_LOGV_STR("Structure field types differ: different fields.");
265e809c
PP		 4998 goto end;
4999 }
265e809c
PP		 5000 }
5001
5002 /* Equal */
5003 ret = 0;
5004
5005end:
5006 return ret;
5007}
5008
5009static
50842bdc
PP		 5010int bt_field_type_variant_compare(struct bt_field_type *type_a,
5011 struct bt_field_type *type_b)
265e809c
PP		 5012{
5013 int ret = 1;
5014 int i;
50842bdc
PP		 5015 struct bt_field_type_variant *variant_a;
5016 struct bt_field_type_variant *variant_b;
265e809c
PP		 5017
5018 variant_a = container_of(type_a,
50842bdc 5019 struct bt_field_type_variant, parent);
265e809c 5020 variant_b = container_of(type_b,
50842bdc 5021 struct bt_field_type_variant, parent);
265e809c
PP		 5022
5023 /* Tag name */
5024 if (strcmp(variant_a->tag_name->str, variant_b->tag_name->str)) {
4e8304f7 5025 BT_LOGV("Variant field types differ: different tag field names: "
32e87ceb 5026 "ft-a-tag-field-name=\"%s\", ft-b-tag-field-name=\"%s\"",
4e8304f7 5027 variant_a->tag_name->str, variant_b->tag_name->str);
265e809c
PP		 5028 goto end;
5029 }
5030
5031 /* Tag type */
50842bdc
PP		 5032 ret = bt_field_type_compare(
5033 (struct bt_field_type *) variant_a->tag,
5034 (struct bt_field_type *) variant_b->tag);
265e809c 5035 if (ret) {
4e8304f7
PP		 5036 BT_LOGV("Variant field types differ: different tag field types: "
5037 "ft-a-tag-ft-addr=%p, ft-b-tag-ft-addr=%p",
5038 variant_a->tag, variant_b->tag);
265e809c
PP		 5039 goto end;
5040 }
5041
5042 ret = 1;
5043
5044 /* Fields */
5045 if (variant_a->fields->len != variant_b->fields->len) {
4e8304f7
PP		 5046 BT_LOGV("Structure field types differ: different field counts: "
5047 "ft-a-field-count=%u, ft-b-field-count=%u",
5048 variant_a->fields->len, variant_b->fields->len);
265e809c
PP		 5049 goto end;
5050 }
5051
5052 for (i = 0; i < variant_a->fields->len; ++i) {
5053 struct structure_field *field_a =
5054 g_ptr_array_index(variant_a->fields, i);
5055 struct structure_field *field_b =
5056 g_ptr_array_index(variant_b->fields, i);
5057
5058 ret = compare_structure_fields(field_a, field_b);
5059 if (ret) {
4e8304f7
PP		 5060 /* compare_structure_fields() logs what differs */
5061 BT_LOGV_STR("Variant field types differ: different fields.");
265e809c
PP		 5062 goto end;
5063 }
265e809c
PP		 5064 }
5065
5066 /* Equal */
5067 ret = 0;
5068
5069end:
5070 return ret;
5071}
5072
5073static
50842bdc
PP		 5074int bt_field_type_array_compare(struct bt_field_type *type_a,
5075 struct bt_field_type *type_b)
265e809c
PP		 5076{
5077 int ret = 1;
50842bdc
PP		 5078 struct bt_field_type_array *array_a;
5079 struct bt_field_type_array *array_b;
265e809c
PP		 5080
5081 array_a = container_of(type_a,
50842bdc 5082 struct bt_field_type_array, parent);
265e809c 5083 array_b = container_of(type_b,
50842bdc 5084 struct bt_field_type_array, parent);
265e809c
PP		 5085
5086 /* Length */
5087 if (array_a->length != array_b->length) {
4e8304f7
PP		 5088 BT_LOGV("Structure field types differ: different lengths: "
5089 "ft-a-length=%u, ft-b-length=%u",
5090 array_a->length, array_b->length);
265e809c
PP		 5091 goto end;
5092 }
5093
5094 /* Element type */
50842bdc 5095 ret = bt_field_type_compare(array_a->element_type,
265e809c 5096 array_b->element_type);
4e8304f7
PP		 5097 if (ret == 1) {
5098 BT_LOGV("Array field types differ: different element field types: "
5099 "ft-a-element-ft-addr=%p, ft-b-element-ft-addr=%p",
5100 array_a->element_type, array_b->element_type);
5101 }
265e809c
PP		 5102
5103end:
5104 return ret;
5105}
5106
5107static
50842bdc
PP		 5108int bt_field_type_sequence_compare(struct bt_field_type *type_a,
5109 struct bt_field_type *type_b)
265e809c
PP		 5110{
5111 int ret = -1;
50842bdc
PP		 5112 struct bt_field_type_sequence *sequence_a;
5113 struct bt_field_type_sequence *sequence_b;
265e809c
PP		 5114
5115 sequence_a = container_of(type_a,
50842bdc 5116 struct bt_field_type_sequence, parent);
265e809c 5117 sequence_b = container_of(type_b,
50842bdc 5118 struct bt_field_type_sequence, parent);
265e809c
PP		 5119
5120 /* Length name */
5121 if (strcmp(sequence_a->length_field_name->str,
5122 sequence_b->length_field_name->str)) {
4e8304f7 5123 BT_LOGV("Sequence field types differ: different length field names: "
32e87ceb
PP		 5124 "ft-a-length-field-name=\"%s\", "
5125 "ft-b-length-field-name=\"%s\"",
4e8304f7
PP		 5126 sequence_a->length_field_name->str,
5127 sequence_b->length_field_name->str);
265e809c
PP		 5128 goto end;
5129 }
5130
5131 /* Element type */
50842bdc 5132 ret = bt_field_type_compare(sequence_a->element_type,
265e809c 5133 sequence_b->element_type);
4e8304f7
PP		 5134 if (ret == 1) {
5135 BT_LOGV("Sequence field types differ: different element field types: "
5136 "ft-a-element-ft-addr=%p, ft-b-element-ft-addr=%p",
5137 sequence_a->element_type, sequence_b->element_type);
5138 }
265e809c
PP		 5139
5140end:
5141 return ret;
5142}
5143
50842bdc
PP		 5144int bt_field_type_compare(struct bt_field_type *type_a,
5145 struct bt_field_type *type_b)
265e809c
PP		 5146{
5147 int ret = 1;
5148
5149 if (type_a == type_b) {
5150 /* Same reference: equal (even if both are NULL) */
5151 ret = 0;
5152 goto end;
5153 }
5154
4e8304f7
PP		 5155 if (!type_a) {
5156 BT_LOGW_STR("Invalid parameter: field type A is NULL.");
5157 ret = -1;
5158 goto end;
5159 }
5160
5161 if (!type_b) {
5162 BT_LOGW_STR("Invalid parameter: field type B is NULL.");
265e809c
PP		 5163 ret = -1;
5164 goto end;
5165 }
5166
dc3fffef 5167 if (type_a->id != type_b->id) {
265e809c 5168 /* Different type IDs */
4e8304f7
PP		 5169 BT_LOGV("Field types differ: different IDs: "
5170 "ft-a-addr=%p, ft-b-addr=%p, "
5171 "ft-a-id=%s, ft-b-id=%s",
5172 type_a, type_b,
50842bdc
PP		 5173 bt_field_type_id_string(type_a->id),
5174 bt_field_type_id_string(type_b->id));
265e809c
PP		 5175 goto end;
5176 }
5177
50842bdc 5178 if (type_a->id == BT_FIELD_TYPE_ID_UNKNOWN) {
265e809c 5179 /* Both have unknown type IDs */
4e8304f7 5180 BT_LOGW_STR("Invalid parameter: field type IDs are unknown.");
265e809c
PP		 5181 goto end;
5182 }
5183
dc3fffef 5184 ret = type_compare_funcs[type_a->id](type_a, type_b);
4e8304f7
PP		 5185 if (ret == 1) {
5186 BT_LOGV("Field types differ: ft-a-addr=%p, ft-b-addr=%p",
5187 type_a, type_b);
5188 }
265e809c
PP		 5189
5190end:
5191 return ret;
5192}
09840de5
PP		 5193
5194BT_HIDDEN
50842bdc 5195int64_t bt_field_type_get_field_count(struct bt_field_type *field_type)
09840de5 5196{
544d0515 5197 int64_t field_count = -1;
50842bdc 5198 enum bt_field_type_id type_id = bt_field_type_get_type_id(field_type);
09840de5
PP		 5199
5200 switch (type_id) {
5201 case CTF_TYPE_STRUCT:
5202 field_count =
50842bdc 5203 bt_field_type_structure_get_field_count(field_type);
09840de5
PP		 5204 break;
5205 case CTF_TYPE_VARIANT:
5206 field_count =
50842bdc 5207 bt_field_type_variant_get_field_count(field_type);
09840de5
PP		 5208 break;
5209 case CTF_TYPE_ARRAY:
5210 case CTF_TYPE_SEQUENCE:
5211 /*
5212 * Array and sequence types always contain a single member
5213 * (the element type).
5214 */
5215 field_count = 1;
5216 break;
5217 default:
5218 break;
5219 }
5220
5221 return field_count;
5222}
5223
5224BT_HIDDEN
50842bdc
PP		 5225struct bt_field_type *bt_field_type_get_field_at_index(
5226 struct bt_field_type *field_type, int index)
09840de5 5227{
50842bdc
PP		 5228 struct bt_field_type *field = NULL;
5229 enum bt_field_type_id type_id = bt_field_type_get_type_id(field_type);
09840de5
PP		 5230
5231 switch (type_id) {
5232 case CTF_TYPE_STRUCT:
aa15981c 5233 {
50842bdc 5234 int ret = bt_field_type_structure_get_field_by_index(
aa15981c
MD		 5235 field_type, NULL, &field, index);
5236 if (ret) {
5237 field = NULL;
5238 goto end;
5239 }
09840de5 5240 break;
aa15981c 5241 }
09840de5 5242 case CTF_TYPE_VARIANT:
8f3a93d9 5243 {
50842bdc 5244 int ret = bt_field_type_variant_get_field_by_index(
9ac68eb1 5245 field_type, NULL, &field, index);
8f3a93d9
JG		 5246 if (ret) {
5247 field = NULL;
5248 goto end;
5249 }
09840de5 5250 break;
8f3a93d9 5251 }
09840de5 5252 case CTF_TYPE_ARRAY:
50842bdc 5253 field = bt_field_type_array_get_element_type(field_type);
09840de5
PP		 5254 break;
5255 case CTF_TYPE_SEQUENCE:
50842bdc 5256 field = bt_field_type_sequence_get_element_type(field_type);
09840de5
PP		 5257 break;
5258 default:
5259 break;
5260 }
8f3a93d9 5261end:
09840de5
PP		 5262 return field;
5263}
5264
5265BT_HIDDEN
50842bdc 5266int bt_field_type_get_field_index(struct bt_field_type *field_type,
09840de5
PP		 5267 const char *name)
5268{
5269 int field_index = -1;
50842bdc 5270 enum bt_field_type_id type_id = bt_field_type_get_type_id(field_type);
09840de5
PP		 5271
5272 switch (type_id) {
5273 case CTF_TYPE_STRUCT:
50842bdc 5274 field_index = bt_field_type_structure_get_field_name_index(
09840de5
PP		 5275 field_type, name);
5276 break;
5277 case CTF_TYPE_VARIANT:
50842bdc 5278 field_index = bt_field_type_variant_get_field_name_index(
09840de5
PP		 5279 field_type, name);
5280 break;
5281 default:
5282 break;
5283 }
5284
5285 return field_index;
5286}
b011f6b0 5287
50842bdc
PP		 5288struct bt_field_path *bt_field_type_variant_get_tag_field_path(
5289 struct bt_field_type *type)
b011f6b0 5290{
50842bdc
PP		 5291 struct bt_field_path *field_path = NULL;
5292 struct bt_field_type_variant *variant;
b011f6b0 5293
4e8304f7
PP		 5294 if (!type) {
5295 BT_LOGW_STR("Invalid parameter: field type is NULL.");
5296 goto end;
5297 }
5298
50842bdc 5299 if (!bt_field_type_is_variant(type)) {
4e8304f7
PP		 5300 BT_LOGW("Invalid parameter: field type is not a variant field type: "
5301 "addr=%p, ft-id=%s", type,
50842bdc 5302 bt_field_type_id_string(type->id));
b011f6b0
PP		 5303 goto end;
5304 }
5305
50842bdc 5306 variant = container_of(type, struct bt_field_type_variant,
b011f6b0
PP		 5307 parent);
5308 field_path = bt_get(variant->tag_field_path);
5309end:
5310 return field_path;
5311}
5312
50842bdc
PP		 5313struct bt_field_path *bt_field_type_sequence_get_length_field_path(
5314 struct bt_field_type *type)
b011f6b0 5315{
50842bdc
PP		 5316 struct bt_field_path *field_path = NULL;
5317 struct bt_field_type_sequence *sequence;
b011f6b0 5318
4e8304f7
PP		 5319 if (!type) {
5320 BT_LOGW_STR("Invalid parameter: field type is NULL.");
5321 goto end;
5322 }
5323
50842bdc 5324 if (!bt_field_type_is_sequence(type)) {
4e8304f7
PP		 5325 BT_LOGW("Invalid parameter: field type is not a sequence field type: "
5326 "addr=%p, ft-id=%s", type,
50842bdc 5327 bt_field_type_id_string(type->id));
b011f6b0
PP		 5328 goto end;
5329 }
5330
50842bdc 5331 sequence = container_of(type, struct bt_field_type_sequence,
b011f6b0
PP		 5332 parent);
5333 field_path = bt_get(sequence->length_field_path);
5334end:
5335 return field_path;
5336}
BabelTrace - Trace Format Babel Tower
This page took 0.355316 seconds and 4 git commands to generate.