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