projects / babeltrace.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
lib: add internal object pool API and use it; adapt plugins/tests
[babeltrace.git] / lib / ctf-ir / fields.c
... / ...
CommitLineData
1/*
2 * fields.c
3 *
4 * Babeltrace CTF IR - Event Fields
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#define BT_LOG_TAG "FIELDS"
30#include <babeltrace/lib-logging-internal.h>
31
32#include <babeltrace/assert-pre-internal.h>
33#include <babeltrace/ctf-ir/fields-internal.h>
34#include <babeltrace/ctf-ir/field-types-internal.h>
35#include <babeltrace/object-internal.h>
36#include <babeltrace/ref.h>
37#include <babeltrace/compiler-internal.h>
38#include <babeltrace/compat/fcntl-internal.h>
39#include <babeltrace/align-internal.h>
40#include <babeltrace/assert-internal.h>
41#include <inttypes.h>
42
43#define BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(_field, _name) \
44 BT_ASSERT_PRE((_field)->type->id == BT_FIELD_TYPE_ID_INTEGER || \
45 (_field)->type->id == BT_FIELD_TYPE_ID_ENUM, \
46 _name " is not an integer or an enumeration field: " \
47 "%!+f", (_field))
48
49static struct bt_field_common_methods bt_field_integer_methods = {
50 .set_is_frozen = bt_field_common_generic_set_is_frozen,
51 .validate = bt_field_common_generic_validate,
52 .copy = NULL,
53 .is_set = bt_field_common_generic_is_set,
54 .reset = bt_field_common_generic_reset,
55};
56
57static struct bt_field_common_methods bt_field_floating_point_methods = {
58 .set_is_frozen = bt_field_common_generic_set_is_frozen,
59 .validate = bt_field_common_generic_validate,
60 .copy = NULL,
61 .is_set = bt_field_common_generic_is_set,
62 .reset = bt_field_common_generic_reset,
63};
64
65static struct bt_field_common_methods bt_field_enumeration_methods = {
66 .set_is_frozen = bt_field_common_generic_set_is_frozen,
67 .validate = bt_field_common_generic_validate,
68 .copy = NULL,
69 .is_set = bt_field_common_generic_is_set,
70 .reset = bt_field_common_generic_reset,
71};
72
73static struct bt_field_common_methods bt_field_string_methods = {
74 .set_is_frozen = bt_field_common_generic_set_is_frozen,
75 .validate = bt_field_common_generic_validate,
76 .copy = NULL,
77 .is_set = bt_field_common_generic_is_set,
78 .reset = bt_field_common_string_reset,
79};
80
81static struct bt_field_common_methods bt_field_structure_methods = {
82 .set_is_frozen = bt_field_common_structure_set_is_frozen_recursive,
83 .validate = bt_field_common_structure_validate_recursive,
84 .copy = NULL,
85 .is_set = bt_field_common_structure_is_set_recursive,
86 .reset = bt_field_common_structure_reset_recursive,
87};
88
89static struct bt_field_common_methods bt_field_sequence_methods = {
90 .set_is_frozen = bt_field_common_sequence_set_is_frozen_recursive,
91 .validate = bt_field_common_sequence_validate_recursive,
92 .copy = NULL,
93 .is_set = bt_field_common_sequence_is_set_recursive,
94 .reset = bt_field_common_sequence_reset_recursive,
95};
96
97static struct bt_field_common_methods bt_field_array_methods = {
98 .set_is_frozen = bt_field_common_array_set_is_frozen_recursive,
99 .validate = bt_field_common_array_validate_recursive,
100 .copy = NULL,
101 .is_set = bt_field_common_array_is_set_recursive,
102 .reset = bt_field_common_array_reset_recursive,
103};
104
105static struct bt_field_common_methods bt_field_variant_methods = {
106 .set_is_frozen = bt_field_common_variant_set_is_frozen_recursive,
107 .validate = bt_field_common_variant_validate_recursive,
108 .copy = NULL,
109 .is_set = bt_field_common_variant_is_set_recursive,
110 .reset = bt_field_common_variant_reset_recursive,
111};
112
113static
114struct bt_field *bt_field_integer_create(struct bt_field_type *);
115
116static
117struct bt_field *bt_field_enumeration_create(struct bt_field_type *);
118
119static
120struct bt_field *bt_field_floating_point_create(struct bt_field_type *);
121
122static
123struct bt_field *bt_field_structure_create(struct bt_field_type *);
124
125static
126struct bt_field *bt_field_variant_create(struct bt_field_type *);
127
128static
129struct bt_field *bt_field_array_create(struct bt_field_type *);
130
131static
132struct bt_field *bt_field_sequence_create(struct bt_field_type *);
133
134static
135struct bt_field *bt_field_string_create(struct bt_field_type *);
136
137static
138struct bt_field *(* const field_create_funcs[])(struct bt_field_type *) = {
139 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_integer_create,
140 [BT_FIELD_TYPE_ID_ENUM] = bt_field_enumeration_create,
141 [BT_FIELD_TYPE_ID_FLOAT] = bt_field_floating_point_create,
142 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_structure_create,
143 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_variant_create,
144 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_array_create,
145 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_sequence_create,
146 [BT_FIELD_TYPE_ID_STRING] = bt_field_string_create,
147};
148
149static
150void bt_field_integer_destroy(struct bt_field *field);
151
152static
153void bt_field_enumeration_destroy(struct bt_field *field);
154
155static
156void bt_field_floating_point_destroy(struct bt_field *field);
157
158static
159void bt_field_structure_destroy_recursive(struct bt_field *field);
160
161static
162void bt_field_variant_destroy_recursive(struct bt_field *field);
163
164static
165void bt_field_array_destroy_recursive(struct bt_field *field);
166
167static
168void bt_field_sequence_destroy_recursive(struct bt_field *field);
169
170static
171void bt_field_string_destroy(struct bt_field *field);
172
173static
174void (* const field_destroy_funcs[])(struct bt_field *) = {
175 [BT_FIELD_TYPE_ID_INTEGER] = bt_field_integer_destroy,
176 [BT_FIELD_TYPE_ID_ENUM] = bt_field_enumeration_destroy,
177 [BT_FIELD_TYPE_ID_FLOAT] = bt_field_floating_point_destroy,
178 [BT_FIELD_TYPE_ID_STRUCT] = bt_field_structure_destroy_recursive,
179 [BT_FIELD_TYPE_ID_VARIANT] = bt_field_variant_destroy_recursive,
180 [BT_FIELD_TYPE_ID_ARRAY] = bt_field_array_destroy_recursive,
181 [BT_FIELD_TYPE_ID_SEQUENCE] = bt_field_sequence_destroy_recursive,
182 [BT_FIELD_TYPE_ID_STRING] = bt_field_string_destroy,
183};
184
185BT_HIDDEN
186struct bt_field *bt_field_create_recursive(struct bt_field_type *type)
187{
188 struct bt_field *field = NULL;
189 enum bt_field_type_id type_id;
190
191 BT_ASSERT_PRE_NON_NULL(type, "Field type");
192 BT_ASSERT(field_type_common_has_known_id((void *) type));
193 BT_ASSERT_PRE(bt_field_type_common_validate((void *) type) == 0,
194 "Field type is invalid: %!+F", type);
195 type_id = bt_field_type_get_type_id(type);
196 field = field_create_funcs[type_id](type);
197 if (!field) {
198 goto end;
199 }
200
201 bt_object_set_is_shared((void *) field, false);
202 bt_field_type_freeze(type);
203
204end:
205 return field;
206}
207
208struct bt_field_type *bt_field_borrow_type(struct bt_field *field)
209{
210 return (void *) bt_field_common_borrow_type((void *) field);
211}
212
213enum bt_field_type_id bt_field_get_type_id(struct bt_field *field)
214{
215 struct bt_field_common *field_common = (void *) field;
216
217 BT_ASSERT_PRE_NON_NULL(field, "Field");
218 return field_common->type->id;
219}
220
221bt_bool bt_field_is_integer(struct bt_field *field)
222{
223 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_INTEGER;
224}
225
226bt_bool bt_field_is_floating_point(struct bt_field *field)
227{
228 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_FLOAT;
229}
230
231bt_bool bt_field_is_enumeration(struct bt_field *field)
232{
233 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_ENUM;
234}
235
236bt_bool bt_field_is_string(struct bt_field *field)
237{
238 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_STRING;
239}
240
241bt_bool bt_field_is_structure(struct bt_field *field)
242{
243 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_STRUCT;
244}
245
246bt_bool bt_field_is_array(struct bt_field *field)
247{
248 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_ARRAY;
249}
250
251bt_bool bt_field_is_sequence(struct bt_field *field)
252{
253 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_SEQUENCE;
254}
255
256bt_bool bt_field_is_variant(struct bt_field *field)
257{
258 return bt_field_get_type_id(field) == BT_FIELD_TYPE_ID_VARIANT;
259}
260
261int64_t bt_field_sequence_get_length(struct bt_field *field)
262{
263 return bt_field_common_sequence_get_length((void *) field);
264}
265
266int bt_field_sequence_set_length(struct bt_field *field, uint64_t length)
267{
268 return bt_field_common_sequence_set_length((void *) field,
269 length, (bt_field_common_create_func) bt_field_create_recursive);
270}
271
272struct bt_field *bt_field_structure_borrow_field_by_index(
273 struct bt_field *field, uint64_t index)
274{
275 return (void *) bt_field_common_structure_borrow_field_by_index(
276 (void *) field, index);
277}
278
279struct bt_field *bt_field_structure_borrow_field_by_name(
280 struct bt_field *field, const char *name)
281{
282 return (void *) bt_field_common_structure_borrow_field_by_name(
283 (void *) field, name);
284}
285
286struct bt_field *bt_field_array_borrow_field(
287 struct bt_field *field, uint64_t index)
288{
289 return (void *) bt_field_common_array_borrow_field((void *) field,
290 index);
291}
292
293struct bt_field *bt_field_sequence_borrow_field(
294 struct bt_field *field, uint64_t index)
295{
296 return (void *) bt_field_common_sequence_borrow_field((void *) field,
297 index);
298}
299
300struct bt_field *bt_field_variant_borrow_current_field(
301 struct bt_field *variant_field)
302{
303 return (void *) bt_field_common_variant_borrow_current_field(
304 (void *) variant_field);
305}
306
307int bt_field_variant_set_tag_signed(struct bt_field *variant_field,
308 int64_t tag)
309{
310 return bt_field_variant_common_set_tag((void *) variant_field,
311 (uint64_t) tag, true);
312}
313
314int bt_field_variant_set_tag_unsigned(struct bt_field *variant_field,
315 uint64_t tag)
316{
317 return bt_field_variant_common_set_tag((void *) variant_field,
318 (uint64_t) tag, false);
319}
320
321int bt_field_variant_get_tag_signed(struct bt_field *variant_field,
322 int64_t *tag)
323{
324 return bt_field_common_variant_get_tag_signed((void *) variant_field, tag);
325}
326
327int bt_field_variant_get_tag_unsigned(struct bt_field *variant_field,
328 uint64_t *tag)
329{
330 return bt_field_common_variant_get_tag_unsigned((void *) variant_field, tag);
331}
332
333struct bt_field_type_enumeration_mapping_iterator *
334bt_field_enumeration_get_mappings(struct bt_field *field)
335{
336 struct bt_field_enumeration *enum_field = (void *) field;
337
338 BT_ASSERT_PRE_NON_NULL(field, "Enumeration field");
339 BT_ASSERT_PRE_FIELD_COMMON_HAS_TYPE_ID((struct bt_field_common *) field,
340 BT_FIELD_TYPE_ID_ENUM, "Field");
341 BT_ASSERT_PRE_FIELD_COMMON_IS_SET((struct bt_field_common *) field,
342 "Enumeration field");
343 return bt_field_common_enumeration_get_mappings((void *) field,
344 (bt_field_common_create_func) bt_field_create_recursive,
345 enum_field->common.payload.unsignd);
346}
347
348BT_ASSERT_PRE_FUNC
349static inline
350struct bt_field_type_common_integer *get_int_enum_int_ft(
351 struct bt_field *field)
352{
353 struct bt_field_common_integer *int_field = (void *) field;
354 struct bt_field_type_common_integer *int_ft = NULL;
355
356 if (int_field->common.type->id == BT_FIELD_TYPE_ID_INTEGER) {
357 int_ft = BT_FROM_COMMON(int_field->common.type);
358 } else if (int_field->common.type->id == BT_FIELD_TYPE_ID_ENUM) {
359 struct bt_field_type_common_enumeration *enum_ft =
360 BT_FROM_COMMON(int_field->common.type);
361 int_ft = enum_ft->container_ft;
362 }
363
364 BT_ASSERT(int_ft);
365 return int_ft;
366}
367
368int bt_field_integer_signed_get_value(struct bt_field *field, int64_t *value)
369{
370 struct bt_field_common_integer *integer = (void *) field;
371
372 BT_ASSERT_PRE_NON_NULL(field, "Integer/enumeration field");
373 BT_ASSERT_PRE_NON_NULL(value, "Value");
374 BT_ASSERT_PRE_FIELD_COMMON_IS_SET(BT_TO_COMMON(integer),
375 "Integer/enumeration field");
376 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
377 BT_ASSERT_PRE(bt_field_type_common_integer_is_signed(
378 BT_TO_COMMON(get_int_enum_int_ft(field))),
379 "Field's type is unsigned: %!+f", field);
380 *value = integer->payload.signd;
381 return 0;
382}
383
384int bt_field_integer_signed_set_value(struct bt_field *field, int64_t value)
385{
386 int ret = 0;
387 struct bt_field_common_integer *integer = (void *) field;
388
389 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
390 BT_ASSERT_PRE_FIELD_COMMON_HOT(BT_TO_COMMON(integer), "Integer field");
391 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
392 BT_ASSERT_PRE(bt_field_type_common_integer_is_signed(
393 BT_FROM_COMMON(get_int_enum_int_ft(field))),
394 "Field's type is unsigned: %!+f", field);
395 BT_ASSERT_PRE(value_is_in_range_signed(
396 get_int_enum_int_ft(field)->size, value),
397 "Value is out of bounds: value=%" PRId64 ", %![field-]+f",
398 value, field);
399 integer->payload.signd = value;
400 bt_field_set(field, true);
401 return ret;
402}
403
404int bt_field_integer_unsigned_get_value(struct bt_field *field, uint64_t *value)
405{
406 struct bt_field_common_integer *integer = (void *) field;
407
408 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
409 BT_ASSERT_PRE_NON_NULL(value, "Value");
410 BT_ASSERT_PRE_FIELD_COMMON_IS_SET(BT_TO_COMMON(integer), "Integer field");
411 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
412 BT_ASSERT_PRE(!bt_field_type_common_integer_is_signed(
413 BT_FROM_COMMON(get_int_enum_int_ft(field))),
414 "Field's type is signed: %!+f", field);
415 *value = integer->payload.unsignd;
416 return 0;
417}
418
419int bt_field_integer_unsigned_set_value(struct bt_field *field,
420 uint64_t value)
421{
422 struct bt_field_common_integer *integer = (void *) field;
423
424 BT_ASSERT_PRE_NON_NULL(field, "Integer field");
425 BT_ASSERT_PRE_FIELD_COMMON_HOT(BT_TO_COMMON(integer), "Integer field");
426 BT_ASSERT_PRE_FIELD_IS_INT_OR_ENUM(BT_TO_COMMON(integer), "Field");
427 BT_ASSERT_PRE(!bt_field_type_common_integer_is_signed(
428 BT_FROM_COMMON(get_int_enum_int_ft(field))),
429 "Field's type is signed: %!+f", field);
430 BT_ASSERT_PRE(value_is_in_range_unsigned(
431 get_int_enum_int_ft(field)->size, value),
432 "Value is out of bounds: value=%" PRIu64 ", %![field-]+f",
433 value, field);
434 integer->payload.unsignd = value;
435 bt_field_set(field, true);
436 return 0;
437}
438
439int bt_field_floating_point_get_value(struct bt_field *field,
440 double *value)
441{
442 return bt_field_common_floating_point_get_value((void *) field, value);
443}
444
445int bt_field_floating_point_set_value(struct bt_field *field,
446 double value)
447{
448 return bt_field_common_floating_point_set_value((void *) field, value);
449}
450
451const char *bt_field_string_get_value(struct bt_field *field)
452{
453 return bt_field_common_string_get_value((void *) field);
454}
455
456int bt_field_string_set_value(struct bt_field *field, const char *value)
457{
458 return bt_field_common_string_set_value((void *) field, value);
459}
460
461int bt_field_string_append(struct bt_field *field, const char *value)
462{
463 return bt_field_common_string_append((void *) field, value);
464}
465
466int bt_field_string_append_len(struct bt_field *field,
467 const char *value, unsigned int length)
468{
469 return bt_field_common_string_append_len((void *) field, value, length);
470}
471
472int bt_field_string_clear(struct bt_field *string_field)
473{
474 return bt_field_common_string_clear((void *) string_field);
475}
476
477BT_HIDDEN
478struct bt_field_common *bt_field_common_copy(struct bt_field_common *field)
479{
480 struct bt_field_common *copy = NULL;
481
482 BT_ASSERT_PRE_NON_NULL(field, "Field");
483 BT_ASSERT(field_type_common_has_known_id(field->type));
484 BT_ASSERT(field->methods->copy);
485 copy = field->methods->copy(field);
486 if (!copy) {
487 BT_LOGW("Cannot create field: ft-addr=%p", field->type);
488 goto end;
489 }
490
491 bt_field_common_set(copy, field->payload_set);
492
493end:
494 return copy;
495}
496
497static
498void bt_field_integer_destroy(struct bt_field *field)
499{
500 BT_LOGD("Destroying integer field object: addr=%p", field);
501 bt_field_common_integer_finalize((void *) field);
502 g_free(field);
503}
504
505static
506void bt_field_floating_point_destroy(struct bt_field *field)
507{
508 BT_LOGD("Destroying floating point field object: addr=%p", field);
509 bt_field_common_floating_point_finalize((void *) field);
510 g_free(field);
511}
512
513static
514void bt_field_enumeration_destroy(struct bt_field *field)
515{
516 BT_LOGD("Destroying enumeration field object: addr=%p", field);
517 bt_field_common_finalize((void *) field);
518 g_free(field);
519}
520
521static
522void bt_field_structure_destroy_recursive(struct bt_field *field)
523{
524 BT_LOGD("Destroying structure field object: addr=%p", field);
525 bt_field_common_structure_finalize_recursive((void *) field);
526 g_free(field);
527}
528
529static
530void bt_field_variant_destroy_recursive(struct bt_field *field)
531{
532 BT_LOGD("Destroying variant field object: addr=%p", field);
533 bt_field_common_variant_finalize_recursive((void *) field);
534 g_free(field);
535}
536
537static
538void bt_field_array_destroy_recursive(struct bt_field *field)
539{
540 BT_LOGD("Destroying array field object: addr=%p", field);
541 bt_field_common_array_finalize_recursive((void *) field);
542 g_free(field);
543}
544
545static
546void bt_field_sequence_destroy_recursive(struct bt_field *field)
547{
548 BT_LOGD("Destroying sequence field object: addr=%p", field);
549 bt_field_common_sequence_finalize_recursive((void *) field);
550 g_free(field);
551}
552
553static
554void bt_field_string_destroy(struct bt_field *field)
555{
556 BT_LOGD("Destroying string field object: addr=%p", field);
557 bt_field_common_string_finalize((void *) field);
558 g_free(field);
559}
560
561BT_HIDDEN
562void bt_field_destroy_recursive(struct bt_field *field)
563{
564 struct bt_field_common *field_common = (void *) field;
565
566 if (!field) {
567 return;
568 }
569
570 BT_ASSERT(field_type_common_has_known_id((void *) field_common->type));
571 field_destroy_funcs[field_common->type->id](field);
572}
573
574static
575struct bt_field *bt_field_integer_create(struct bt_field_type *type)
576{
577 struct bt_field_common_integer *integer =
578 g_new0(struct bt_field_common_integer, 1);
579
580 BT_LOGD("Creating integer field object: ft-addr=%p", type);
581
582 if (integer) {
583 bt_field_common_initialize(BT_TO_COMMON(integer), (void *) type,
584 NULL, &bt_field_integer_methods);
585 BT_LOGD("Created integer field object: addr=%p, ft-addr=%p",
586 integer, type);
587 } else {
588 BT_LOGE_STR("Failed to allocate one integer field.");
589 }
590
591 return (void *) integer;
592}
593
594static
595struct bt_field *bt_field_enumeration_create(struct bt_field_type *type)
596{
597 struct bt_field_enumeration *enumeration = g_new0(
598 struct bt_field_enumeration, 1);
599
600 BT_LOGD("Creating enumeration field object: ft-addr=%p", type);
601
602 if (enumeration) {
603 bt_field_common_initialize(
604 BT_TO_COMMON(BT_TO_COMMON(enumeration)),
605 (void *) type, NULL, &bt_field_enumeration_methods);
606 BT_LOGD("Created enumeration field object: addr=%p, ft-addr=%p",
607 enumeration, type);
608 } else {
609 BT_LOGE_STR("Failed to allocate one enumeration field.");
610 }
611
612 return (void *) enumeration;
613}
614
615static
616struct bt_field *bt_field_floating_point_create(struct bt_field_type *type)
617{
618 struct bt_field_common_floating_point *floating_point;
619
620 BT_LOGD("Creating floating point number field object: ft-addr=%p", type);
621 floating_point = g_new0(struct bt_field_common_floating_point, 1);
622
623 if (floating_point) {
624 bt_field_common_initialize(BT_TO_COMMON(floating_point),
625 (void *) type, NULL, &bt_field_floating_point_methods);
626 BT_LOGD("Created floating point number field object: addr=%p, ft-addr=%p",
627 floating_point, type);
628 } else {
629 BT_LOGE_STR("Failed to allocate one floating point number field.");
630 }
631
632 return (void *) floating_point;
633}
634
635BT_HIDDEN
636int bt_field_common_structure_initialize(struct bt_field_common *field,
637 struct bt_field_type_common *type,
638 bt_object_release_func release_func,
639 struct bt_field_common_methods *methods,
640 bt_field_common_create_func field_create_func,
641 GDestroyNotify field_release_func)
642{
643 int ret = 0;
644 struct bt_field_type_common_structure *structure_type =
645 BT_FROM_COMMON(type);
646 struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
647 size_t i;
648
649 BT_LOGD("Initializing common structure field object: ft-addr=%p", type);
650 bt_field_common_initialize(field, type, release_func, methods);
651 structure->fields = g_ptr_array_new_with_free_func(field_release_func);
652 g_ptr_array_set_size(structure->fields, structure_type->fields->len);
653
654 /* Create all fields contained in the structure field. */
655 for (i = 0; i < structure_type->fields->len; i++) {
656 struct bt_field_common *field;
657 struct bt_field_type_common_structure_field *struct_field =
658 BT_FIELD_TYPE_COMMON_STRUCTURE_FIELD_AT_INDEX(
659 structure_type, i);
660 field = field_create_func(struct_field->type);
661 if (!field) {
662 BT_LOGE("Failed to create structure field's member: name=\"%s\", index=%zu",
663 g_quark_to_string(struct_field->name), i);
664 ret = -1;
665 goto end;
666 }
667
668 g_ptr_array_index(structure->fields, i) = field;
669 }
670
671 BT_LOGD("Initialized common structure field object: addr=%p, ft-addr=%p",
672 field, type);
673
674end:
675 return ret;
676}
677
678static
679struct bt_field *bt_field_structure_create(struct bt_field_type *type)
680{
681 struct bt_field_common_structure *structure = g_new0(
682 struct bt_field_common_structure, 1);
683 int iret;
684
685 BT_LOGD("Creating structure field object: ft-addr=%p", type);
686
687 if (!structure) {
688 BT_LOGE_STR("Failed to allocate one structure field.");
689 goto end;
690 }
691
692 iret = bt_field_common_structure_initialize(BT_TO_COMMON(structure),
693 (void *) type, NULL, &bt_field_structure_methods,
694 (bt_field_common_create_func) bt_field_create_recursive,
695 (GDestroyNotify) bt_field_destroy_recursive);
696 if (iret) {
697 BT_PUT(structure);
698 goto end;
699 }
700
701 BT_LOGD("Created structure field object: addr=%p, ft-addr=%p",
702 structure, type);
703
704end:
705 return (void *) structure;
706}
707
708BT_HIDDEN
709int bt_field_common_variant_initialize(struct bt_field_common *field,
710 struct bt_field_type_common *type,
711 bt_object_release_func release_func,
712 struct bt_field_common_methods *methods,
713 bt_field_common_create_func field_create_func,
714 GDestroyNotify field_release_func)
715{
716 int ret = 0;
717 struct bt_field_type_common_variant *variant_type =
718 BT_FROM_COMMON(type);
719 struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
720 size_t i;
721
722 BT_LOGD("Initializing common variant field object: ft-addr=%p", type);
723 bt_field_common_initialize(field, type, release_func, methods);
724 ret = bt_field_type_common_variant_update_choices(type);
725 if (ret) {
726 BT_LOGE("Cannot update common variant field type choices: "
727 "ret=%d", ret);
728 goto end;
729 }
730
731 variant->fields = g_ptr_array_new_with_free_func(field_release_func);
732 g_ptr_array_set_size(variant->fields, variant_type->choices->len);
733
734 /* Create all fields contained in the variant field. */
735 for (i = 0; i < variant_type->choices->len; i++) {
736 struct bt_field_common *field;
737 struct bt_field_type_common_variant_choice *var_choice =
738 BT_FIELD_TYPE_COMMON_VARIANT_CHOICE_AT_INDEX(
739 variant_type, i);
740
741 field = field_create_func(var_choice->type);
742 if (!field) {
743 BT_LOGE("Failed to create variant field's member: name=\"%s\", index=%zu",
744 g_quark_to_string(var_choice->name), i);
745 ret = -1;
746 goto end;
747 }
748
749 g_ptr_array_index(variant->fields, i) = field;
750 }
751
752 BT_LOGD("Initialized common variant field object: addr=%p, ft-addr=%p",
753 field, type);
754
755end:
756 return ret;
757}
758
759static
760struct bt_field *bt_field_variant_create(struct bt_field_type *type)
761{
762 struct bt_field_common_variant *variant = g_new0(
763 struct bt_field_common_variant, 1);
764 int iret;
765
766 BT_LOGD("Creating variant field object: ft-addr=%p", type);
767
768 if (!variant) {
769 BT_LOGE_STR("Failed to allocate one variant field.");
770 goto end;
771 }
772
773 iret = bt_field_common_variant_initialize(BT_TO_COMMON(variant),
774 (void *) type, NULL, &bt_field_variant_methods,
775 (bt_field_common_create_func) bt_field_create_recursive,
776 (GDestroyNotify) bt_field_destroy_recursive);
777 if (iret) {
778 BT_PUT(variant);
779 goto end;
780 }
781
782 BT_LOGD("Created variant field object: addr=%p, ft-addr=%p",
783 variant, type);
784
785end:
786 return (void *) variant;
787}
788
789BT_HIDDEN
790int bt_field_common_array_initialize(struct bt_field_common *field,
791 struct bt_field_type_common *type,
792 bt_object_release_func release_func,
793 struct bt_field_common_methods *methods,
794 bt_field_common_create_func field_create_func,
795 GDestroyNotify field_destroy_func)
796{
797 struct bt_field_type_common_array *array_type = BT_FROM_COMMON(type);
798 struct bt_field_common_array *array = BT_FROM_COMMON(field);
799 unsigned int array_length;
800 int ret = 0;
801 uint64_t i;
802
803 BT_LOGD("Initializing common array field object: ft-addr=%p", type);
804 BT_ASSERT(type);
805 bt_field_common_initialize(field, type, release_func, methods);
806 array_length = array_type->length;
807 array->elements = g_ptr_array_sized_new(array_length);
808 if (!array->elements) {
809 ret = -1;
810 goto end;
811 }
812
813 g_ptr_array_set_free_func(array->elements, field_destroy_func);
814 g_ptr_array_set_size(array->elements, array_length);
815
816 for (i = 0; i < array_length; i++) {
817 array->elements->pdata[i] = field_create_func(
818 array_type->element_ft);
819 if (!array->elements->pdata[i]) {
820 ret = -1;
821 goto end;
822 }
823 }
824
825 BT_LOGD("Initialized common array field object: addr=%p, ft-addr=%p",
826 field, type);
827
828end:
829 return ret;
830}
831
832static
833struct bt_field *bt_field_array_create(struct bt_field_type *type)
834{
835 struct bt_field_common_array *array =
836 g_new0(struct bt_field_common_array, 1);
837 int ret;
838
839 BT_LOGD("Creating array field object: ft-addr=%p", type);
840 BT_ASSERT(type);
841
842 if (!array) {
843 BT_LOGE_STR("Failed to allocate one array field.");
844 goto end;
845 }
846
847 ret = bt_field_common_array_initialize(BT_TO_COMMON(array),
848 (void *) type, NULL, &bt_field_array_methods,
849 (bt_field_common_create_func) bt_field_create_recursive,
850 (GDestroyNotify) bt_field_destroy_recursive);
851 if (ret) {
852 BT_PUT(array);
853 goto end;
854 }
855
856 BT_LOGD("Created array field object: addr=%p, ft-addr=%p",
857 array, type);
858
859end:
860 return (void *) array;
861}
862
863BT_HIDDEN
864int bt_field_common_sequence_initialize(struct bt_field_common *field,
865 struct bt_field_type_common *type,
866 bt_object_release_func release_func,
867 struct bt_field_common_methods *methods,
868 GDestroyNotify field_destroy_func)
869{
870 struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
871 int ret = 0;
872
873 BT_LOGD("Initializing common sequence field object: ft-addr=%p", type);
874 BT_ASSERT(type);
875 bt_field_common_initialize(field, type, release_func, methods);
876 sequence->elements = g_ptr_array_new();
877 if (!sequence->elements) {
878 ret = -1;
879 goto end;
880 }
881
882 g_ptr_array_set_free_func(sequence->elements, field_destroy_func);
883 BT_LOGD("Initialized common sequence field object: addr=%p, ft-addr=%p",
884 field, type);
885
886end:
887 return ret;
888}
889
890static
891struct bt_field *bt_field_sequence_create(struct bt_field_type *type)
892{
893 struct bt_field_common_sequence *sequence =
894 g_new0(struct bt_field_common_sequence, 1);
895 int ret;
896
897 BT_LOGD("Creating sequence field object: ft-addr=%p", type);
898 BT_ASSERT(type);
899
900 if (!sequence) {
901 BT_LOGE_STR("Failed to allocate one sequence field.");
902 goto end;
903 }
904
905 ret = bt_field_common_sequence_initialize(BT_TO_COMMON(sequence),
906 (void *) type, NULL, &bt_field_sequence_methods,
907 (GDestroyNotify) bt_field_destroy_recursive);
908 if (ret) {
909 BT_PUT(sequence);
910 goto end;
911 }
912
913 BT_LOGD("Created sequence field object: addr=%p, ft-addr=%p",
914 sequence, type);
915
916end:
917 return (void *) sequence;
918}
919
920static
921struct bt_field *bt_field_string_create(struct bt_field_type *type)
922{
923 struct bt_field_common_string *string = g_new0(
924 struct bt_field_common_string, 1);
925
926 BT_LOGD("Creating string field object: ft-addr=%p", type);
927
928 if (string) {
929 bt_field_common_initialize(BT_TO_COMMON(string),
930 (void *) type, NULL, &bt_field_string_methods);
931 BT_LOGD("Created string field object: addr=%p, ft-addr=%p",
932 string, type);
933 } else {
934 BT_LOGE_STR("Failed to allocate one string field.");
935 }
936
937 return (void *) string;
938}
939
940BT_HIDDEN
941int bt_field_common_generic_validate(struct bt_field_common *field)
942{
943 return (field && field->payload_set) ? 0 : -1;
944}
945
946BT_HIDDEN
947int bt_field_common_structure_validate_recursive(struct bt_field_common *field)
948{
949 int64_t i;
950 int ret = 0;
951 struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
952
953 BT_ASSERT(field);
954
955 for (i = 0; i < structure->fields->len; i++) {
956 ret = bt_field_common_validate_recursive(
957 (void *) structure->fields->pdata[i]);
958
959 if (ret) {
960 int this_ret;
961 const char *name;
962
963 this_ret = bt_field_type_common_structure_borrow_field_by_index(
964 field->type, &name, NULL, i);
965 BT_ASSERT(this_ret == 0);
966 BT_ASSERT_PRE_MSG("Invalid structure field's field: "
967 "%![struct-field-]+_f, field-name=\"%s\", "
968 "index=%" PRId64 ", %![field-]+_f",
969 field, name, i, structure->fields->pdata[i]);
970 goto end;
971 }
972 }
973
974end:
975 return ret;
976}
977
978BT_HIDDEN
979int bt_field_common_variant_validate_recursive(struct bt_field_common *field)
980{
981 int ret = 0;
982 struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
983
984 BT_ASSERT(field);
985
986 if (!variant->current_field) {
987 ret = -1;
988 goto end;
989 }
990
991 ret = bt_field_common_validate_recursive(variant->current_field);
992
993end:
994 return ret;
995}
996
997BT_HIDDEN
998int bt_field_common_array_validate_recursive(struct bt_field_common *field)
999{
1000 int64_t i;
1001 int ret = 0;
1002 struct bt_field_common_array *array = BT_FROM_COMMON(field);
1003
1004 BT_ASSERT(field);
1005
1006 for (i = 0; i < array->elements->len; i++) {
1007 ret = bt_field_common_validate_recursive((void *) array->elements->pdata[i]);
1008 if (ret) {
1009 BT_ASSERT_PRE_MSG("Invalid array field's element field: "
1010 "%![array-field-]+_f, " PRId64 ", "
1011 "%![elem-field-]+_f",
1012 field, i, array->elements->pdata[i]);
1013 goto end;
1014 }
1015 }
1016
1017end:
1018 return ret;
1019}
1020
1021BT_HIDDEN
1022int bt_field_common_sequence_validate_recursive(struct bt_field_common *field)
1023{
1024 size_t i;
1025 int ret = 0;
1026 struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
1027
1028 BT_ASSERT(field);
1029
1030 for (i = 0; i < sequence->elements->len; i++) {
1031 ret = bt_field_common_validate_recursive(
1032 (void *) sequence->elements->pdata[i]);
1033 if (ret) {
1034 BT_ASSERT_PRE_MSG("Invalid sequence field's element field: "
1035 "%![seq-field-]+_f, " PRId64 ", "
1036 "%![elem-field-]+_f",
1037 field, i, sequence->elements->pdata[i]);
1038 goto end;
1039 }
1040 }
1041end:
1042 return ret;
1043}
1044
1045BT_HIDDEN
1046void bt_field_common_generic_reset(struct bt_field_common *field)
1047{
1048 BT_ASSERT(field);
1049 field->payload_set = false;
1050}
1051
1052BT_HIDDEN
1053void bt_field_common_structure_reset_recursive(struct bt_field_common *field)
1054{
1055 int64_t i;
1056 struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
1057
1058 BT_ASSERT(field);
1059
1060 for (i = 0; i < structure->fields->len; i++) {
1061 struct bt_field_common *member = structure->fields->pdata[i];
1062
1063 if (!member) {
1064 /*
1065 * Structure members are lazily initialized;
1066 * skip if this member has not been allocated
1067 * yet.
1068 */
1069 continue;
1070 }
1071
1072 bt_field_common_reset_recursive(member);
1073 }
1074}
1075
1076BT_HIDDEN
1077void bt_field_common_variant_reset_recursive(struct bt_field_common *field)
1078{
1079 struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
1080
1081 BT_ASSERT(field);
1082 variant->current_field = NULL;
1083}
1084
1085BT_HIDDEN
1086void bt_field_common_array_reset_recursive(struct bt_field_common *field)
1087{
1088 size_t i;
1089 struct bt_field_common_array *array = BT_FROM_COMMON(field);
1090
1091 BT_ASSERT(field);
1092
1093 for (i = 0; i < array->elements->len; i++) {
1094 struct bt_field_common *member = array->elements->pdata[i];
1095
1096 if (!member) {
1097 /*
1098 * Array elements are lazily initialized; skip
1099 * if this member has not been allocated yet.
1100 */
1101 continue;
1102 }
1103
1104 bt_field_common_reset_recursive(member);
1105 }
1106}
1107
1108BT_HIDDEN
1109void bt_field_common_sequence_reset_recursive(struct bt_field_common *field)
1110{
1111 struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
1112 uint64_t i;
1113
1114 BT_ASSERT(field);
1115
1116 for (i = 0; i < sequence->elements->len; i++) {
1117 if (sequence->elements->pdata[i]) {
1118 bt_field_common_reset_recursive(
1119 sequence->elements->pdata[i]);
1120 }
1121 }
1122
1123 sequence->length = 0;
1124}
1125
1126BT_HIDDEN
1127void bt_field_common_string_reset(struct bt_field_common *field)
1128{
1129 struct bt_field_common_string *string = BT_FROM_COMMON(field);
1130
1131 BT_ASSERT(field);
1132 bt_field_common_generic_reset(field);
1133
1134 if (string->payload) {
1135 g_string_truncate(string->payload, 0);
1136 }
1137}
1138
1139BT_HIDDEN
1140void bt_field_common_generic_set_is_frozen(struct bt_field_common *field,
1141 bool is_frozen)
1142{
1143 field->frozen = is_frozen;
1144}
1145
1146BT_HIDDEN
1147void bt_field_common_structure_set_is_frozen_recursive(
1148 struct bt_field_common *field, bool is_frozen)
1149{
1150 uint64_t i;
1151 struct bt_field_common_structure *structure_field =
1152 BT_FROM_COMMON(field);
1153
1154 BT_LOGD("Freezing structure field object: addr=%p", field);
1155
1156 for (i = 0; i < structure_field->fields->len; i++) {
1157 struct bt_field_common *struct_field =
1158 g_ptr_array_index(structure_field->fields, i);
1159
1160 BT_LOGD("Freezing structure field's field: field-addr=%p, index=%" PRId64,
1161 struct_field, i);
1162 bt_field_common_set_is_frozen_recursive(struct_field,
1163 is_frozen);
1164 }
1165
1166 bt_field_common_generic_set_is_frozen(field, is_frozen);
1167}
1168
1169BT_HIDDEN
1170void bt_field_common_variant_set_is_frozen_recursive(
1171 struct bt_field_common *field, bool is_frozen)
1172{
1173 uint64_t i;
1174 struct bt_field_common_variant *variant_field = BT_FROM_COMMON(field);
1175
1176 BT_LOGD("Freezing variant field object: addr=%p", field);
1177
1178 for (i = 0; i < variant_field->fields->len; i++) {
1179 struct bt_field_common *var_field =
1180 g_ptr_array_index(variant_field->fields, i);
1181
1182 BT_LOGD("Freezing variant field's field: field-addr=%p, index=%" PRId64,
1183 var_field, i);
1184 bt_field_common_set_is_frozen_recursive(var_field, is_frozen);
1185 }
1186
1187 bt_field_common_generic_set_is_frozen(field, is_frozen);
1188}
1189
1190BT_HIDDEN
1191void bt_field_common_array_set_is_frozen_recursive(
1192 struct bt_field_common *field, bool is_frozen)
1193{
1194 int64_t i;
1195 struct bt_field_common_array *array_field = BT_FROM_COMMON(field);
1196
1197 BT_LOGD("Freezing array field object: addr=%p", field);
1198
1199 for (i = 0; i < array_field->elements->len; i++) {
1200 struct bt_field_common *elem_field =
1201 g_ptr_array_index(array_field->elements, i);
1202
1203 BT_LOGD("Freezing array field object's element field: "
1204 "element-field-addr=%p, index=%" PRId64,
1205 elem_field, i);
1206 bt_field_common_set_is_frozen_recursive(elem_field, is_frozen);
1207 }
1208
1209 bt_field_common_generic_set_is_frozen(field, is_frozen);
1210}
1211
1212BT_HIDDEN
1213void bt_field_common_sequence_set_is_frozen_recursive(
1214 struct bt_field_common *field, bool is_frozen)
1215{
1216 int64_t i;
1217 struct bt_field_common_sequence *sequence_field =
1218 BT_FROM_COMMON(field);
1219
1220 BT_LOGD("Freezing sequence field object: addr=%p", field);
1221
1222 for (i = 0; i < sequence_field->length; i++) {
1223 struct bt_field_common *elem_field =
1224 g_ptr_array_index(sequence_field->elements, i);
1225
1226 BT_LOGD("Freezing sequence field object's element field: "
1227 "element-field-addr=%p, index=%" PRId64,
1228 elem_field, i);
1229 bt_field_common_set_is_frozen_recursive(elem_field, is_frozen);
1230 }
1231
1232 bt_field_common_generic_set_is_frozen(field, is_frozen);
1233}
1234
1235BT_HIDDEN
1236void _bt_field_common_set_is_frozen_recursive(struct bt_field_common *field,
1237 bool is_frozen)
1238{
1239 if (!field) {
1240 goto end;
1241 }
1242
1243 if (field->frozen) {
1244 goto end;
1245 }
1246
1247 BT_LOGD("Setting field object's frozen state: addr=%p, is-frozen=%d",
1248 field, is_frozen);
1249 BT_ASSERT(field_type_common_has_known_id(field->type));
1250 BT_ASSERT(field->methods->set_is_frozen);
1251 field->methods->set_is_frozen(field, is_frozen);
1252
1253end:
1254 return;
1255}
1256
1257BT_HIDDEN
1258bt_bool bt_field_common_generic_is_set(struct bt_field_common *field)
1259{
1260 return field && field->payload_set;
1261}
1262
1263BT_HIDDEN
1264bt_bool bt_field_common_structure_is_set_recursive(
1265 struct bt_field_common *field)
1266{
1267 bt_bool is_set = BT_FALSE;
1268 size_t i;
1269 struct bt_field_common_structure *structure = BT_FROM_COMMON(field);
1270
1271 BT_ASSERT(field);
1272
1273 for (i = 0; i < structure->fields->len; i++) {
1274 is_set = bt_field_common_is_set_recursive(
1275 structure->fields->pdata[i]);
1276 if (!is_set) {
1277 goto end;
1278 }
1279 }
1280
1281end:
1282 return is_set;
1283}
1284
1285BT_HIDDEN
1286bt_bool bt_field_common_variant_is_set_recursive(struct bt_field_common *field)
1287{
1288 struct bt_field_common_variant *variant = BT_FROM_COMMON(field);
1289 bt_bool is_set = BT_FALSE;
1290
1291 BT_ASSERT(field);
1292
1293 if (variant->current_field) {
1294 is_set = bt_field_common_is_set_recursive(
1295 variant->current_field);
1296 }
1297
1298 return is_set;
1299}
1300
1301BT_HIDDEN
1302bt_bool bt_field_common_array_is_set_recursive(struct bt_field_common *field)
1303{
1304 size_t i;
1305 bt_bool is_set = BT_FALSE;
1306 struct bt_field_common_array *array = BT_FROM_COMMON(field);
1307
1308 BT_ASSERT(field);
1309
1310 for (i = 0; i < array->elements->len; i++) {
1311 is_set = bt_field_common_is_set_recursive(array->elements->pdata[i]);
1312 if (!is_set) {
1313 goto end;
1314 }
1315 }
1316
1317end:
1318 return is_set;
1319}
1320
1321BT_HIDDEN
1322bt_bool bt_field_common_sequence_is_set_recursive(struct bt_field_common *field)
1323{
1324 size_t i;
1325 bt_bool is_set = BT_FALSE;
1326 struct bt_field_common_sequence *sequence = BT_FROM_COMMON(field);
1327
1328 BT_ASSERT(field);
1329
1330 if (!sequence->elements) {
1331 goto end;
1332 }
1333
1334 for (i = 0; i < sequence->elements->len; i++) {
1335 is_set = bt_field_common_is_set_recursive(
1336 sequence->elements->pdata[i]);
1337 if (!is_set) {
1338 goto end;
1339 }
1340 }
1341
1342end:
1343 return is_set;
1344}
BabelTrace - Trace Format Babel Tower
This page took 0.027409 seconds and 4 git commands to generate.