3893f911eb0cbe5b6a0209ecf501d50c04236057
[babeltrace.git] / src / ctf-writer / fields.h
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 *
6 * The Common Trace Format (CTF) Specification is available at
7 * http://www.efficios.com/ctf
8 */
9
10 #ifndef BABELTRACE_CTF_WRITER_FIELDS_INTERNAL_H
11 #define BABELTRACE_CTF_WRITER_FIELDS_INTERNAL_H
12
13 #include <glib.h>
14 #include <inttypes.h>
15 #include <stdbool.h>
16 #include <stddef.h>
17 #include <stdint.h>
18 #include <string.h>
19
20 #include <babeltrace2-ctf-writer/fields.h>
21 #include <babeltrace2/types.h>
22
23 #include "common/macros.h"
24 #include "common/common.h"
25 #include "ctfser/ctfser.h"
26
27 #include "assert-pre.h"
28 #include "field-types.h"
29 #include "object.h"
30 #include "utils.h"
31
32 #define BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(_field, _type_id, _name) \
33 BT_CTF_ASSERT_PRE((_field)->type->id == ((int) (_type_id)), \
34 _name " has the wrong type ID: expected-type-id=%s, " \
35 "field-addr=%p", \
36 bt_ctf_field_type_id_string((int) (_type_id)), (_field))
37
38 #define BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(_field, _name) \
39 BT_CTF_ASSERT_PRE(bt_ctf_field_common_is_set_recursive(_field), \
40 _name " is not set: field-addr=%p", (_field))
41
42 #define BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HOT(_field, _name) \
43 BT_CTF_ASSERT_PRE_HOT((_field), (_name), ": field-addr=%p", (_field))
44
45 struct bt_ctf_field_common;
46
47 typedef void (*bt_ctf_field_common_method_set_is_frozen)(struct bt_ctf_field_common *,
48 bool);
49 typedef int (*bt_ctf_field_common_method_validate)(struct bt_ctf_field_common *);
50 typedef struct bt_ctf_field_common *(*bt_ctf_field_common_method_copy)(
51 struct bt_ctf_field_common *);
52 typedef bt_ctf_bool (*bt_ctf_field_common_method_is_set)(struct bt_ctf_field_common *);
53 typedef void (*bt_ctf_field_common_method_reset)(struct bt_ctf_field_common *);
54
55 struct bt_ctf_field_common_methods {
56 bt_ctf_field_common_method_set_is_frozen set_is_frozen;
57 bt_ctf_field_common_method_validate validate;
58 bt_ctf_field_common_method_copy copy;
59 bt_ctf_field_common_method_is_set is_set;
60 bt_ctf_field_common_method_reset reset;
61 };
62
63 struct bt_ctf_field_common {
64 struct bt_ctf_object base;
65 struct bt_ctf_field_type_common *type;
66 struct bt_ctf_field_common_methods *methods;
67 bool payload_set;
68 bool frozen;
69
70 /*
71 * Specialized data for either CTF IR or CTF writer APIs.
72 * See comment in `field-types.h` for more details.
73 */
74 union {
75 struct {
76 } ir;
77 struct {
78 void *serialize_func;
79 } writer;
80 } spec;
81 };
82
83 struct bt_ctf_field_common_integer {
84 struct bt_ctf_field_common common;
85 union {
86 int64_t signd;
87 uint64_t unsignd;
88 } payload;
89 };
90
91 struct bt_ctf_field_common_floating_point {
92 struct bt_ctf_field_common common;
93 double payload;
94 };
95
96 struct bt_ctf_field_common_structure {
97 struct bt_ctf_field_common common;
98
99 /* Array of `struct bt_ctf_field_common *`, owned by this */
100 GPtrArray *fields;
101 };
102
103 struct bt_ctf_field_common_variant {
104 struct bt_ctf_field_common common;
105
106 union {
107 uint64_t u;
108 int64_t i;
109 } tag_value;
110
111 /* Weak: belongs to `choices` below */
112 struct bt_ctf_field_common *current_field;
113
114 /* Array of `struct bt_ctf_field_common *`, owned by this */
115 GPtrArray *fields;
116 };
117
118 struct bt_ctf_field_common_array {
119 struct bt_ctf_field_common common;
120
121 /* Array of `struct bt_ctf_field_common *`, owned by this */
122 GPtrArray *elements;
123 };
124
125 struct bt_ctf_field_common_sequence {
126 struct bt_ctf_field_common common;
127
128 /*
129 * This is the true sequence field's length: its value can be
130 * less than `elements->len` below because we never shrink the
131 * array of elements to avoid reallocation.
132 */
133 uint64_t length;
134
135 /* Array of `struct bt_ctf_field_common *`, owned by this */
136 GPtrArray *elements;
137 };
138
139 struct bt_ctf_field_common_string {
140 struct bt_ctf_field_common common;
141 GArray *buf;
142 size_t size;
143 };
144
145 struct bt_ctf_field_common *bt_ctf_field_common_copy(struct bt_ctf_field_common *field);
146
147 int bt_ctf_field_common_structure_initialize(struct bt_ctf_field_common *field,
148 struct bt_ctf_field_type_common *type,
149 bool is_shared, bt_ctf_object_release_func release_func,
150 struct bt_ctf_field_common_methods *methods,
151 bt_ctf_field_common_create_func field_create_func,
152 GDestroyNotify field_release_func);
153
154 int bt_ctf_field_common_array_initialize(struct bt_ctf_field_common *field,
155 struct bt_ctf_field_type_common *type,
156 bool is_shared, bt_ctf_object_release_func release_func,
157 struct bt_ctf_field_common_methods *methods,
158 bt_ctf_field_common_create_func field_create_func,
159 GDestroyNotify field_destroy_func);
160
161 int bt_ctf_field_common_sequence_initialize(struct bt_ctf_field_common *field,
162 struct bt_ctf_field_type_common *type,
163 bool is_shared, bt_ctf_object_release_func release_func,
164 struct bt_ctf_field_common_methods *methods,
165 GDestroyNotify field_destroy_func);
166
167 int bt_ctf_field_common_variant_initialize(struct bt_ctf_field_common *field,
168 struct bt_ctf_field_type_common *type,
169 bool is_shared, bt_ctf_object_release_func release_func,
170 struct bt_ctf_field_common_methods *methods,
171 bt_ctf_field_common_create_func field_create_func,
172 GDestroyNotify field_release_func);
173
174 int bt_ctf_field_common_string_initialize(struct bt_ctf_field_common *field,
175 struct bt_ctf_field_type_common *type,
176 bool is_shared, bt_ctf_object_release_func release_func,
177 struct bt_ctf_field_common_methods *methods);
178
179 int bt_ctf_field_common_generic_validate(struct bt_ctf_field_common *field);
180
181 int bt_ctf_field_common_structure_validate_recursive(struct bt_ctf_field_common *field);
182
183 int bt_ctf_field_common_variant_validate_recursive(struct bt_ctf_field_common *field);
184
185 int bt_ctf_field_common_array_validate_recursive(struct bt_ctf_field_common *field);
186
187 int bt_ctf_field_common_sequence_validate_recursive(struct bt_ctf_field_common *field);
188
189 void bt_ctf_field_common_generic_reset(struct bt_ctf_field_common *field);
190
191 void bt_ctf_field_common_structure_reset_recursive(struct bt_ctf_field_common *field);
192
193 void bt_ctf_field_common_variant_reset_recursive(struct bt_ctf_field_common *field);
194
195 void bt_ctf_field_common_array_reset_recursive(struct bt_ctf_field_common *field);
196
197 void bt_ctf_field_common_sequence_reset_recursive(struct bt_ctf_field_common *field);
198
199 void bt_ctf_field_common_generic_set_is_frozen(struct bt_ctf_field_common *field,
200 bool is_frozen);
201
202 void bt_ctf_field_common_structure_set_is_frozen_recursive(
203 struct bt_ctf_field_common *field, bool is_frozen);
204
205 void bt_ctf_field_common_variant_set_is_frozen_recursive(
206 struct bt_ctf_field_common *field, bool is_frozen);
207
208 void bt_ctf_field_common_array_set_is_frozen_recursive(
209 struct bt_ctf_field_common *field, bool is_frozen);
210
211 void bt_ctf_field_common_sequence_set_is_frozen_recursive(
212 struct bt_ctf_field_common *field, bool is_frozen);
213
214 void _bt_ctf_field_common_set_is_frozen_recursive(struct bt_ctf_field_common *field,
215 bool is_frozen);
216
217 bt_ctf_bool bt_ctf_field_common_generic_is_set(struct bt_ctf_field_common *field);
218
219 bt_ctf_bool bt_ctf_field_common_structure_is_set_recursive(
220 struct bt_ctf_field_common *field);
221
222 bt_ctf_bool bt_ctf_field_common_variant_is_set_recursive(struct bt_ctf_field_common *field);
223
224 bt_ctf_bool bt_ctf_field_common_array_is_set_recursive(struct bt_ctf_field_common *field);
225
226 bt_ctf_bool bt_ctf_field_common_sequence_is_set_recursive(struct bt_ctf_field_common *field);
227
228 #ifdef BT_DEV_MODE
229 # define bt_ctf_field_common_validate_recursive _bt_ctf_field_common_validate_recursive
230 # define bt_ctf_field_common_set_is_frozen_recursive _bt_ctf_field_common_set_is_frozen_recursive
231 # define bt_ctf_field_common_is_set_recursive _bt_ctf_field_common_is_set_recursive
232 # define bt_ctf_field_common_reset_recursive _bt_ctf_field_common_reset_recursive
233 # define bt_ctf_field_common_set _bt_ctf_field_common_set
234 #else
235 # define bt_ctf_field_common_validate_recursive(_field) (-1)
236 # define bt_ctf_field_common_set_is_frozen_recursive(_field, _is_frozen)
237 # define bt_ctf_field_common_is_set_recursive(_field) (BT_CTF_FALSE)
238 # define bt_ctf_field_common_reset_recursive(_field)
239 # define bt_ctf_field_common_set(_field, _val)
240 #endif
241
242 BT_ASSERT_DBG_FUNC
243 static inline bool field_type_common_has_known_id(
244 struct bt_ctf_field_type_common *ft)
245 {
246 return (int) ft->id > BT_CTF_FIELD_TYPE_ID_UNKNOWN &&
247 (int) ft->id < BT_CTF_FIELD_TYPE_ID_NR;
248 }
249
250 static inline
251 int _bt_ctf_field_common_validate_recursive(struct bt_ctf_field_common *field)
252 {
253 int ret = 0;
254
255 if (!field) {
256 BT_CTF_ASSERT_PRE_MSG("%s", "Invalid field: field is NULL.");
257 ret = -1;
258 goto end;
259 }
260
261 BT_ASSERT_DBG(field_type_common_has_known_id(field->type));
262
263 if (field->methods->validate) {
264 ret = field->methods->validate(field);
265 }
266
267 end:
268 return ret;
269 }
270
271 static inline
272 void _bt_ctf_field_common_reset_recursive(struct bt_ctf_field_common *field)
273 {
274 BT_ASSERT_DBG(field);
275 BT_ASSERT_DBG(field->methods->reset);
276 field->methods->reset(field);
277 }
278
279 static inline
280 void _bt_ctf_field_common_set(struct bt_ctf_field_common *field, bool value)
281 {
282 BT_ASSERT_DBG(field);
283 field->payload_set = value;
284 }
285
286 static inline
287 bt_ctf_bool _bt_ctf_field_common_is_set_recursive(struct bt_ctf_field_common *field)
288 {
289 bt_ctf_bool is_set = BT_CTF_FALSE;
290
291 if (!field) {
292 goto end;
293 }
294
295 BT_ASSERT_DBG(field_type_common_has_known_id(field->type));
296 BT_ASSERT_DBG(field->methods->is_set);
297 is_set = field->methods->is_set(field);
298
299 end:
300 return is_set;
301 }
302
303 static inline
304 void bt_ctf_field_common_initialize(struct bt_ctf_field_common *field,
305 struct bt_ctf_field_type_common *ft, bool is_shared,
306 bt_ctf_object_release_func release_func,
307 struct bt_ctf_field_common_methods *methods)
308 {
309 BT_ASSERT_DBG(field);
310 BT_ASSERT_DBG(ft);
311 bt_ctf_object_init(&field->base, is_shared, release_func);
312 field->methods = methods;
313 field->type = (void *) bt_ctf_object_get_ref(ft);
314 }
315
316 static inline
317 struct bt_ctf_field_type_common *bt_ctf_field_common_borrow_type(
318 struct bt_ctf_field_common *field)
319 {
320 struct bt_ctf_field_type_common *ret = NULL;
321
322 BT_CTF_ASSERT_PRE_NON_NULL(field, "Field");
323 ret = field->type;
324 return ret;
325 }
326
327 static inline
328 int64_t bt_ctf_field_common_sequence_get_length(struct bt_ctf_field_common *field)
329 {
330 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
331
332 BT_CTF_ASSERT_PRE_NON_NULL(field, "Sequence field");
333 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field, BT_CTF_FIELD_TYPE_ID_SEQUENCE,
334 "Field");
335 return (int64_t) sequence->length;
336 }
337
338 static inline
339 int bt_ctf_field_common_sequence_set_length(struct bt_ctf_field_common *field,
340 uint64_t length, bt_ctf_field_common_create_func field_create_func)
341 {
342 int ret = 0;
343 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
344
345 BT_CTF_ASSERT_PRE_NON_NULL(field, "Sequence field");
346 BT_CTF_ASSERT_PRE(((int64_t) length) >= 0,
347 "Invalid sequence length (too large): length=%" PRId64,
348 length);
349 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HOT(field, "Sequence field");
350
351 if (G_UNLIKELY(length > sequence->elements->len)) {
352 /* Make more room */
353 struct bt_ctf_field_type_common_sequence *sequence_ft;
354 uint64_t cur_len = sequence->elements->len;
355 uint64_t i;
356
357 g_ptr_array_set_size(sequence->elements, length);
358 sequence_ft = BT_CTF_FROM_COMMON(sequence->common.type);
359
360 for (i = cur_len; i < sequence->elements->len; i++) {
361 struct bt_ctf_field_common *elem_field =
362 field_create_func(sequence_ft->element_ft);
363
364 if (!elem_field) {
365 ret = -1;
366 goto end;
367 }
368
369 BT_ASSERT_DBG(!sequence->elements->pdata[i]);
370 sequence->elements->pdata[i] = elem_field;
371 }
372 }
373
374 sequence->length = length;
375
376 end:
377 return ret;
378 }
379
380 static inline
381 struct bt_ctf_field_common *bt_ctf_field_common_structure_borrow_field_by_name(
382 struct bt_ctf_field_common *field, const char *name)
383 {
384 struct bt_ctf_field_common *ret = NULL;
385 GQuark field_quark;
386 struct bt_ctf_field_type_common_structure *structure_ft;
387 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
388 size_t index;
389 GHashTable *field_name_to_index;
390
391 BT_CTF_ASSERT_PRE_NON_NULL(field, "Structure field");
392 BT_CTF_ASSERT_PRE_NON_NULL(name, "Field name");
393 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
394 BT_CTF_FIELD_TYPE_ID_STRUCT, "Field");
395 structure_ft = BT_CTF_FROM_COMMON(field->type);
396 field_name_to_index = structure_ft->field_name_to_index;
397 field_quark = g_quark_from_string(name);
398 if (!g_hash_table_lookup_extended(field_name_to_index,
399 GUINT_TO_POINTER(field_quark),
400 NULL, (gpointer *) &index)) {
401 BT_LOGT("Invalid parameter: no such field in structure field's type: "
402 "struct-field-addr=%p, struct-ft-addr=%p, name=\"%s\"",
403 field, field->type, name);
404 goto error;
405 }
406
407 ret = structure->fields->pdata[index];
408 BT_ASSERT_DBG(ret);
409
410 error:
411 return ret;
412 }
413
414 static inline
415 struct bt_ctf_field_common *bt_ctf_field_common_structure_borrow_field_by_index(
416 struct bt_ctf_field_common *field, uint64_t index)
417 {
418 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
419
420 BT_CTF_ASSERT_PRE_NON_NULL(field, "Structure field");
421 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
422 BT_CTF_FIELD_TYPE_ID_STRUCT, "Field");
423 BT_CTF_ASSERT_PRE(index < structure->fields->len,
424 "Index is out of bound: struct-field-addr=%p, "
425 "index=%" PRIu64 ", count=%u", field, index,
426 structure->fields->len);
427 return structure->fields->pdata[index];
428 }
429
430 static inline
431 struct bt_ctf_field_common *bt_ctf_field_common_array_borrow_field(
432 struct bt_ctf_field_common *field, uint64_t index)
433 {
434 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
435
436 BT_CTF_ASSERT_PRE_NON_NULL(field, "Array field");
437 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field, BT_CTF_FIELD_TYPE_ID_ARRAY,
438 "Field");
439 BT_CTF_ASSERT_PRE(index < array->elements->len,
440 "Index is out of bound: array-field-addr=%p, "
441 "index=%" PRIu64 ", count=%u", field,
442 index, array->elements->len);
443 return array->elements->pdata[(size_t) index];
444 }
445
446 static inline
447 struct bt_ctf_field_common *bt_ctf_field_common_sequence_borrow_field(
448 struct bt_ctf_field_common *field, uint64_t index)
449 {
450 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
451
452 BT_CTF_ASSERT_PRE_NON_NULL(field, "Sequence field");
453 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field, BT_CTF_FIELD_TYPE_ID_SEQUENCE,
454 "Field");
455 BT_CTF_ASSERT_PRE(index < sequence->length,
456 "Index is out of bound: seq-field-addr=%p, "
457 "index=%" PRIu64 ", count=%u", field, index,
458 sequence->elements->len);
459 return sequence->elements->pdata[(size_t) index];
460 }
461
462 static inline
463 int bt_ctf_field_common_variant_set_tag(struct bt_ctf_field_common *variant_field,
464 uint64_t tag_uval, bool is_signed)
465 {
466 int ret = 0;
467 int64_t choice_index;
468 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(variant_field);
469
470 BT_CTF_ASSERT_PRE_NON_NULL(variant_field, "Variant field");
471 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(variant_field,
472 BT_CTF_FIELD_TYPE_ID_VARIANT, "Field");
473
474 /* Find matching index in variant field's type */
475 choice_index = bt_ctf_field_type_common_variant_find_choice_index(
476 variant_field->type, tag_uval, is_signed);
477 if (choice_index < 0) {
478 ret = -1;
479 goto end;
480 }
481
482 /* Select corresponding field */
483 BT_ASSERT_DBG(choice_index < variant->fields->len);
484 variant->current_field = variant->fields->pdata[choice_index];
485 variant->tag_value.u = tag_uval;
486
487 end:
488 return ret;
489 }
490
491 static inline
492 struct bt_ctf_field_common *bt_ctf_field_common_variant_borrow_current_field(
493 struct bt_ctf_field_common *variant_field)
494 {
495 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(variant_field);
496
497 BT_CTF_ASSERT_PRE_NON_NULL(variant_field, "Variant field");
498 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(variant_field,
499 BT_CTF_FIELD_TYPE_ID_VARIANT, "Field");
500 BT_CTF_ASSERT_PRE(variant->current_field,
501 "Variant field has no current field: field-addr=%p", variant_field);
502 return variant->current_field;
503 }
504
505 static inline
506 int bt_ctf_field_common_variant_get_tag_signed(struct bt_ctf_field_common *variant_field,
507 int64_t *tag)
508 {
509 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(variant_field);
510
511 BT_CTF_ASSERT_PRE_NON_NULL(variant_field, "Variant field");
512 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(variant_field,
513 BT_CTF_FIELD_TYPE_ID_VARIANT, "Field");
514 BT_CTF_ASSERT_PRE(variant->current_field,
515 "Variant field has no current field: field-addr=%p", variant_field);
516 *tag = variant->tag_value.i;
517 return 0;
518 }
519
520 static inline
521 int bt_ctf_field_common_variant_get_tag_unsigned(struct bt_ctf_field_common *variant_field,
522 uint64_t *tag)
523 {
524 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(variant_field);
525
526 BT_CTF_ASSERT_PRE_NON_NULL(variant_field, "Variant field");
527 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(variant_field,
528 BT_CTF_FIELD_TYPE_ID_VARIANT, "Field");
529 BT_CTF_ASSERT_PRE(variant->current_field,
530 "Variant field has no current field: field-addr=%p", variant_field);
531 *tag = variant->tag_value.u;
532 return 0;
533 }
534
535 static inline
536 int bt_ctf_field_common_floating_point_get_value(struct bt_ctf_field_common *field,
537 double *value)
538 {
539 struct bt_ctf_field_common_floating_point *floating_point =
540 BT_CTF_FROM_COMMON(field);
541
542 BT_CTF_ASSERT_PRE_NON_NULL(field, "Floating point number field");
543 BT_CTF_ASSERT_PRE_NON_NULL(value, "Value");
544 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(field, "Floating point number field");
545 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
546 BT_CTF_FIELD_TYPE_ID_FLOAT, "Field");
547 *value = floating_point->payload;
548 return 0;
549 }
550
551 static inline
552 int bt_ctf_field_common_floating_point_set_value(struct bt_ctf_field_common *field,
553 double value)
554 {
555 struct bt_ctf_field_common_floating_point *floating_point =
556 BT_CTF_FROM_COMMON(field);
557
558 BT_CTF_ASSERT_PRE_NON_NULL(field, "Floating point number field");
559 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HOT(field, "Floating point number field");
560 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
561 BT_CTF_FIELD_TYPE_ID_FLOAT, "Field");
562 floating_point->payload = value;
563 bt_ctf_field_common_set(field, true);
564 return 0;
565 }
566
567 static inline
568 const char *bt_ctf_field_common_string_get_value(struct bt_ctf_field_common *field)
569 {
570 struct bt_ctf_field_common_string *string = BT_CTF_FROM_COMMON(field);
571
572 BT_CTF_ASSERT_PRE_NON_NULL(field, "String field");
573 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_IS_SET(field, "String field");
574 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
575 BT_CTF_FIELD_TYPE_ID_STRING, "Field");
576 return (const char *) string->buf->data;
577 }
578
579 static inline
580 int bt_ctf_field_common_string_clear(struct bt_ctf_field_common *field)
581 {
582 struct bt_ctf_field_common_string *string_field = BT_CTF_FROM_COMMON(field);
583
584 BT_CTF_ASSERT_PRE_NON_NULL(field, "String field");
585 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HOT(field, "String field");
586 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
587 BT_CTF_FIELD_TYPE_ID_STRING, "Field");
588 string_field->size = 0;
589 bt_ctf_field_common_set(field, true);
590 return 0;
591 }
592
593 static inline
594 int bt_ctf_field_common_string_append_len(struct bt_ctf_field_common *field,
595 const char *value, unsigned int length)
596 {
597 struct bt_ctf_field_common_string *string_field = BT_CTF_FROM_COMMON(field);
598 char *data;
599 size_t new_size;
600
601 BT_CTF_ASSERT_PRE_NON_NULL(field, "String field");
602 BT_CTF_ASSERT_PRE_NON_NULL(value, "Value");
603 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HOT(field, "String field");
604 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
605 BT_CTF_FIELD_TYPE_ID_STRING, "Field");
606
607 /* Make sure no null bytes are appended */
608 BT_CTF_ASSERT_PRE(!memchr(value, '\0', length),
609 "String value to append contains a null character: "
610 "partial-value=\"%.32s\", length=%u", value, length);
611
612 new_size = string_field->size + length;
613
614 if (G_UNLIKELY(new_size + 1 > string_field->buf->len)) {
615 g_array_set_size(string_field->buf, new_size + 1);
616 }
617
618 data = string_field->buf->data;
619 memcpy(data + string_field->size, value, length);
620 ((char *) string_field->buf->data)[new_size] = '\0';
621 string_field->size = new_size;
622 bt_ctf_field_common_set(field, true);
623 return 0;
624 }
625
626 static inline
627 int bt_ctf_field_common_string_append(struct bt_ctf_field_common *field,
628 const char *value)
629 {
630 BT_CTF_ASSERT_PRE_NON_NULL(value, "Value");
631 return bt_ctf_field_common_string_append_len(field, value,
632 strlen(value));
633 }
634
635 static inline
636 int bt_ctf_field_common_string_set_value(struct bt_ctf_field_common *field,
637 const char *value)
638 {
639 BT_CTF_ASSERT_PRE_NON_NULL(field, "String field");
640 BT_CTF_ASSERT_PRE_NON_NULL(value, "Value");
641 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HOT(field, "String field");
642 BT_CTF_ASSERT_PRE_CTF_FIELD_COMMON_HAS_TYPE_ID(field,
643 BT_CTF_FIELD_TYPE_ID_STRING, "Field");
644 bt_ctf_field_common_string_clear(field);
645 return bt_ctf_field_common_string_append_len(field,
646 value, strlen(value));
647 }
648
649 static inline
650 void bt_ctf_field_common_finalize(struct bt_ctf_field_common *field)
651 {
652 BT_ASSERT_DBG(field);
653 BT_LOGD_STR("Putting field's type.");
654 bt_ctf_object_put_ref(field->type);
655 }
656
657 static inline
658 void bt_ctf_field_common_integer_finalize(struct bt_ctf_field_common *field)
659 {
660 BT_ASSERT_DBG(field);
661 BT_LOGD("Finalizing common integer field object: addr=%p", field);
662 bt_ctf_field_common_finalize(field);
663 }
664
665 static inline
666 void bt_ctf_field_common_floating_point_finalize(struct bt_ctf_field_common *field)
667 {
668 BT_ASSERT_DBG(field);
669 BT_LOGD("Finalizing common floating point number field object: addr=%p", field);
670 bt_ctf_field_common_finalize(field);
671 }
672
673 static inline
674 void bt_ctf_field_common_structure_finalize_recursive(struct bt_ctf_field_common *field)
675 {
676 struct bt_ctf_field_common_structure *structure = BT_CTF_FROM_COMMON(field);
677
678 BT_ASSERT_DBG(field);
679 BT_LOGD("Finalizing common structure field object: addr=%p", field);
680 bt_ctf_field_common_finalize(field);
681
682 if (structure->fields) {
683 g_ptr_array_free(structure->fields, TRUE);
684 }
685 }
686
687 static inline
688 void bt_ctf_field_common_variant_finalize_recursive(struct bt_ctf_field_common *field)
689 {
690 struct bt_ctf_field_common_variant *variant = BT_CTF_FROM_COMMON(field);
691
692 BT_ASSERT_DBG(field);
693 BT_LOGD("Finalizing common variant field object: addr=%p", field);
694 bt_ctf_field_common_finalize(field);
695
696 if (variant->fields) {
697 g_ptr_array_free(variant->fields, TRUE);
698 }
699 }
700
701 static inline
702 void bt_ctf_field_common_array_finalize_recursive(struct bt_ctf_field_common *field)
703 {
704 struct bt_ctf_field_common_array *array = BT_CTF_FROM_COMMON(field);
705
706 BT_ASSERT_DBG(field);
707 BT_LOGD("Finalizing common array field object: addr=%p", field);
708 bt_ctf_field_common_finalize(field);
709
710 if (array->elements) {
711 g_ptr_array_free(array->elements, TRUE);
712 }
713 }
714
715 static inline
716 void bt_ctf_field_common_sequence_finalize_recursive(struct bt_ctf_field_common *field)
717 {
718 struct bt_ctf_field_common_sequence *sequence = BT_CTF_FROM_COMMON(field);
719
720 BT_ASSERT_DBG(field);
721 BT_LOGD("Finalizing common sequence field object: addr=%p", field);
722 bt_ctf_field_common_finalize(field);
723
724 if (sequence->elements) {
725 g_ptr_array_free(sequence->elements, TRUE);
726 }
727 }
728
729 static inline
730 void bt_ctf_field_common_string_finalize(struct bt_ctf_field_common *field)
731 {
732 struct bt_ctf_field_common_string *string = BT_CTF_FROM_COMMON(field);
733
734 BT_ASSERT_DBG(field);
735 BT_LOGD("Finalizing common string field object: addr=%p", field);
736 bt_ctf_field_common_finalize(field);
737
738 if (string->buf) {
739 g_array_free(string->buf, TRUE);
740 }
741 }
742
743 BT_CTF_ASSERT_PRE_FUNC
744 static inline bool value_is_in_range_signed(unsigned int size, int64_t value)
745 {
746 bool ret = true;
747 int64_t min_value, max_value;
748
749 min_value = -(1ULL << (size - 1));
750 max_value = (1ULL << (size - 1)) - 1;
751 if (value < min_value || value > max_value) {
752 BT_LOGF("Value is out of bounds: value=%" PRId64 ", "
753 "min-value=%" PRId64 ", max-value=%" PRId64,
754 value, min_value, max_value);
755 ret = false;
756 }
757
758 return ret;
759 }
760
761 BT_CTF_ASSERT_PRE_FUNC
762 static inline bool value_is_in_range_unsigned(unsigned int size, uint64_t value)
763 {
764 bool ret = true;
765 int64_t max_value;
766
767 max_value = (size == 64) ? UINT64_MAX : ((uint64_t) 1 << size) - 1;
768 if (value > max_value) {
769 BT_LOGF("Value is out of bounds: value=%" PRIu64 ", "
770 "max-value=%" PRIu64,
771 value, max_value);
772 ret = false;
773 }
774
775 return ret;
776 }
777
778 struct bt_ctf_field_enumeration {
779 struct bt_ctf_field_common common;
780 struct bt_ctf_field_common_integer *container;
781 };
782
783 struct bt_ctf_field_variant {
784 struct bt_ctf_field_common_variant common;
785 struct bt_ctf_field_enumeration *tag;
786 };
787
788 int bt_ctf_field_serialize_recursive(struct bt_ctf_field *field,
789 struct bt_ctfser *ctfser,
790 enum bt_ctf_byte_order native_byte_order);
791
792 int bt_ctf_field_structure_set_field_by_name(struct bt_ctf_field *field,
793 const char *name, struct bt_ctf_field *value);
794
795 struct bt_ctf_field *bt_ctf_field_enumeration_borrow_container(
796 struct bt_ctf_field *field);
797
798 static inline
799 bt_ctf_bool bt_ctf_field_is_set_recursive(struct bt_ctf_field *field)
800 {
801 return bt_ctf_field_common_is_set_recursive((void *) field);
802 }
803
804 #endif /* BABELTRACE_CTF_WRITER_FIELDS_INTERNAL_H */
This page took 0.044636 seconds and 3 git commands to generate.