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