lib, bt2: rename "signed/unsigned sel." -> "integer signed/unsigned sel."
[babeltrace.git] / src / plugins / text / pretty / print.c
CommitLineData
af9a82eb 1/*
af9a82eb 2 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
f504043c 3 * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
af9a82eb
JG
4 *
5 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 */
25
71c5da58 26#include <babeltrace2/babeltrace.h>
57952005
MJ
27#include "compat/bitfield.h"
28#include "common/common.h"
d126826c 29#include "common/uuid.h"
57952005
MJ
30#include "compat/time.h"
31#include "common/assert.h"
6a18b281 32#include <inttypes.h>
93a4161c 33#include <ctype.h>
85e7137b 34#include <string.h>
3228cc1d 35#include "pretty.h"
af9a82eb 36
1556a1af
JG
37#define NSEC_PER_SEC 1000000000LL
38
5280f742 39#define COLOR_NAME BT_COMMON_COLOR_BOLD
da6febac 40#define COLOR_FIELD_NAME BT_COMMON_COLOR_FG_CYAN
5280f742
PP
41#define COLOR_RST BT_COMMON_COLOR_RESET
42#define COLOR_STRING_VALUE BT_COMMON_COLOR_BOLD
43#define COLOR_NUMBER_VALUE BT_COMMON_COLOR_BOLD
44#define COLOR_ENUM_MAPPING_NAME BT_COMMON_COLOR_BOLD
45#define COLOR_UNKNOWN BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_RED
da6febac 46#define COLOR_EVENT_NAME BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_MAGENTA
5280f742 47#define COLOR_TIMESTAMP BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_YELLOW
ad96d936 48
af9a82eb
JG
49struct timestamp {
50 int64_t real_timestamp; /* Relative to UNIX epoch. */
ecbb78c0 51 uint64_t clock_snapshot; /* In cycles. */
af9a82eb
JG
52};
53
6a18b281 54static
834e9996 55int print_field(struct pretty_component *pretty,
9554ca46 56 const bt_field *field, bool print_names);
6a18b281 57
ad96d936 58static
3228cc1d 59void print_name_equal(struct pretty_component *pretty, const char *name)
ad96d936 60{
3228cc1d 61 if (pretty->use_colors) {
6e8feb63
MD
62 bt_common_g_string_append(pretty->string, COLOR_NAME);
63 bt_common_g_string_append(pretty->string, name);
64 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 65 } else {
6e8feb63 66 bt_common_g_string_append(pretty->string, name);
ad96d936 67 }
6e8feb63 68 bt_common_g_string_append(pretty->string, " = ");
ad96d936
PP
69}
70
71static
3228cc1d 72void print_field_name_equal(struct pretty_component *pretty, const char *name)
ad96d936 73{
3228cc1d 74 if (pretty->use_colors) {
6e8feb63
MD
75 bt_common_g_string_append(pretty->string, COLOR_FIELD_NAME);
76 bt_common_g_string_append(pretty->string, name);
77 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 78 } else {
6e8feb63
MD
79 bt_common_g_string_append(pretty->string, name);
80 }
81 bt_common_g_string_append(pretty->string, " = ");
ad96d936
PP
82}
83
af9a82eb 84static
3228cc1d 85void print_timestamp_cycles(struct pretty_component *pretty,
029ba264 86 const bt_clock_snapshot *clock_snapshot, bool update_last)
af9a82eb 87{
1556a1af 88 uint64_t cycles;
1556a1af 89
ecbb78c0 90 cycles = bt_clock_snapshot_get_value(clock_snapshot);
275fd4d6 91 bt_common_g_string_append_printf(pretty->string, "%020" PRIu64, cycles);
3af83b5a 92
029ba264
PP
93 if (update_last) {
94 if (pretty->last_cycles_timestamp != -1ULL) {
95 pretty->delta_cycles = cycles - pretty->last_cycles_timestamp;
96 }
9c04b633 97
029ba264
PP
98 pretty->last_cycles_timestamp = cycles;
99 }
af9a82eb
JG
100}
101
102static
3228cc1d 103void print_timestamp_wall(struct pretty_component *pretty,
029ba264 104 const bt_clock_snapshot *clock_snapshot, bool update_last)
af9a82eb 105{
1556a1af 106 int ret;
1556a1af
JG
107 int64_t ts_nsec = 0; /* add configurable offset */
108 int64_t ts_sec = 0; /* add configurable offset */
109 uint64_t ts_sec_abs, ts_nsec_abs;
110 bool is_negative;
af9a82eb 111
ecbb78c0 112 if (!clock_snapshot) {
6e8feb63 113 bt_common_g_string_append(pretty->string, "??:??:??.?????????");
1556a1af
JG
114 return;
115 }
116
ecbb78c0 117 ret = bt_clock_snapshot_get_ns_from_origin(clock_snapshot, &ts_nsec);
1556a1af 118 if (ret) {
5280f742 119 // TODO: log, this is unexpected
6e8feb63 120 bt_common_g_string_append(pretty->string, "Error");
1556a1af
JG
121 return;
122 }
123
029ba264
PP
124 if (update_last) {
125 if (pretty->last_real_timestamp != -1ULL) {
126 pretty->delta_real_timestamp = ts_nsec - pretty->last_real_timestamp;
127 }
128
129 pretty->last_real_timestamp = ts_nsec;
3af83b5a 130 }
3af83b5a 131
1556a1af
JG
132 ts_sec += ts_nsec / NSEC_PER_SEC;
133 ts_nsec = ts_nsec % NSEC_PER_SEC;
5280f742 134
1556a1af
JG
135 if (ts_sec >= 0 && ts_nsec >= 0) {
136 is_negative = false;
137 ts_sec_abs = ts_sec;
138 ts_nsec_abs = ts_nsec;
139 } else if (ts_sec > 0 && ts_nsec < 0) {
140 is_negative = false;
141 ts_sec_abs = ts_sec - 1;
142 ts_nsec_abs = NSEC_PER_SEC + ts_nsec;
143 } else if (ts_sec == 0 && ts_nsec < 0) {
144 is_negative = true;
145 ts_sec_abs = ts_sec;
146 ts_nsec_abs = -ts_nsec;
147 } else if (ts_sec < 0 && ts_nsec > 0) {
148 is_negative = true;
149 ts_sec_abs = -(ts_sec + 1);
150 ts_nsec_abs = NSEC_PER_SEC - ts_nsec;
151 } else if (ts_sec < 0 && ts_nsec == 0) {
152 is_negative = true;
153 ts_sec_abs = -ts_sec;
154 ts_nsec_abs = ts_nsec;
155 } else { /* (ts_sec < 0 && ts_nsec < 0) */
156 is_negative = true;
157 ts_sec_abs = -ts_sec;
158 ts_nsec_abs = -ts_nsec;
159 }
160
3228cc1d 161 if (!pretty->options.clock_seconds) {
1556a1af
JG
162 struct tm tm;
163 time_t time_s = (time_t) ts_sec_abs;
164
f1c99b12 165 if (is_negative && !pretty->negative_timestamp_warning_done) {
5280f742 166 // TODO: log instead
1556a1af 167 fprintf(stderr, "[warning] Fallback to [sec.ns] to print negative time value. Use --clock-seconds.\n");
f1c99b12 168 pretty->negative_timestamp_warning_done = true;
1556a1af
JG
169 goto seconds;
170 }
171
3228cc1d 172 if (!pretty->options.clock_gmt) {
1556a1af
JG
173 struct tm *res;
174
58a2480d 175 res = bt_localtime_r(&time_s, &tm);
1556a1af 176 if (!res) {
5280f742 177 // TODO: log instead
1556a1af
JG
178 fprintf(stderr, "[warning] Unable to get localtime.\n");
179 goto seconds;
180 }
181 } else {
182 struct tm *res;
183
58a2480d 184 res = bt_gmtime_r(&time_s, &tm);
1556a1af 185 if (!res) {
5280f742 186 // TODO: log instead
1556a1af
JG
187 fprintf(stderr, "[warning] Unable to get gmtime.\n");
188 goto seconds;
189 }
190 }
3228cc1d 191 if (pretty->options.clock_date) {
1556a1af
JG
192 char timestr[26];
193 size_t res;
194
195 /* Print date and time */
196 res = strftime(timestr, sizeof(timestr),
4d2a94f1 197 "%Y-%m-%d ", &tm);
1556a1af 198 if (!res) {
5280f742 199 // TODO: log instead
1556a1af
JG
200 fprintf(stderr, "[warning] Unable to print ascii time.\n");
201 goto seconds;
202 }
5280f742 203
6e8feb63 204 bt_common_g_string_append(pretty->string, timestr);
1556a1af 205 }
5280f742 206
1556a1af 207 /* Print time in HH:MM:SS.ns */
275fd4d6 208 bt_common_g_string_append_printf(pretty->string,
5280f742
PP
209 "%02d:%02d:%02d.%09" PRIu64, tm.tm_hour, tm.tm_min,
210 tm.tm_sec, ts_nsec_abs);
1556a1af
JG
211 goto end;
212 }
213seconds:
275fd4d6 214 bt_common_g_string_append_printf(pretty->string, "%s%" PRId64 ".%09" PRIu64,
5280f742 215 is_negative ? "-" : "", ts_sec_abs, ts_nsec_abs);
1556a1af
JG
216end:
217 return;
af9a82eb
JG
218}
219
220static
834e9996 221int print_event_timestamp(struct pretty_component *pretty,
9c04b633 222 const bt_message *event_msg, bool *start_line)
af9a82eb 223{
3228cc1d 224 bool print_names = pretty->options.print_header_field_names;
834e9996 225 int ret = 0;
ecbb78c0 226 const bt_clock_snapshot *clock_snapshot = NULL;
af9a82eb 227
b3f050a9
PP
228 if (!bt_message_event_borrow_stream_class_default_clock_class_const(
229 event_msg)) {
9c04b633 230 /* No default clock class: skip the timestamp without an error */
f504043c
MD
231 goto end;
232 }
d9f65f09 233
11ddb3ef 234 clock_snapshot = bt_message_event_borrow_default_clock_snapshot_const(event_msg);
af9a82eb 235
ad96d936 236 if (print_names) {
3228cc1d 237 print_name_equal(pretty, "timestamp");
ad96d936 238 } else {
6e8feb63 239 bt_common_g_string_append(pretty->string, "[");
ad96d936 240 }
3228cc1d 241 if (pretty->use_colors) {
6e8feb63 242 bt_common_g_string_append(pretty->string, COLOR_TIMESTAMP);
ad96d936 243 }
3228cc1d 244 if (pretty->options.print_timestamp_cycles) {
029ba264 245 print_timestamp_cycles(pretty, clock_snapshot, true);
af9a82eb 246 } else {
029ba264 247 print_timestamp_wall(pretty, clock_snapshot, true);
af9a82eb 248 }
3228cc1d 249 if (pretty->use_colors) {
6e8feb63 250 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 251 }
af9a82eb 252
c3c30b08 253 if (!print_names)
6e8feb63 254 bt_common_g_string_append(pretty->string, "] ");
c3c30b08 255
3228cc1d 256 if (pretty->options.print_delta_field) {
ad96d936 257 if (print_names) {
6e8feb63 258 bt_common_g_string_append(pretty->string, ", ");
3228cc1d 259 print_name_equal(pretty, "delta");
ad96d936 260 } else {
6e8feb63 261 bt_common_g_string_append(pretty->string, "(");
ad96d936 262 }
3228cc1d
PP
263 if (pretty->options.print_timestamp_cycles) {
264 if (pretty->delta_cycles == -1ULL) {
6e8feb63 265 bt_common_g_string_append(pretty->string,
50e38eb5 266 "+??????????\?\?"); /* Not a trigraph. */
3af83b5a 267 } else {
275fd4d6 268 bt_common_g_string_append_printf(pretty->string,
5280f742 269 "+%012" PRIu64, pretty->delta_cycles);
3af83b5a
MD
270 }
271 } else {
3228cc1d 272 if (pretty->delta_real_timestamp != -1ULL) {
3af83b5a 273 uint64_t delta_sec, delta_nsec, delta;
f504043c 274
3228cc1d 275 delta = pretty->delta_real_timestamp;
3af83b5a
MD
276 delta_sec = delta / NSEC_PER_SEC;
277 delta_nsec = delta % NSEC_PER_SEC;
275fd4d6 278 bt_common_g_string_append_printf(pretty->string,
5280f742 279 "+%" PRIu64 ".%09" PRIu64,
3af83b5a
MD
280 delta_sec, delta_nsec);
281 } else {
6e8feb63 282 bt_common_g_string_append(pretty->string, "+?.?????????");
3af83b5a
MD
283 }
284 }
285 if (!print_names) {
6e8feb63 286 bt_common_g_string_append(pretty->string, ") ");
3af83b5a
MD
287 }
288 }
289 *start_line = !print_names;
f504043c 290
af9a82eb 291end:
af9a82eb
JG
292 return ret;
293}
294
6a18b281 295static
834e9996 296int print_event_header(struct pretty_component *pretty,
9c04b633 297 const bt_message *event_msg)
af9a82eb 298{
3228cc1d 299 bool print_names = pretty->options.print_header_field_names;
834e9996 300 int ret = 0;
8eee8ea2 301 const bt_event_class *event_class = NULL;
8eee8ea2
PP
302 const bt_stream *stream = NULL;
303 const bt_trace *trace = NULL;
9c04b633 304 const bt_event *event = bt_message_event_borrow_event_const(event_msg);
b4d7c117 305 const char *ev_name;
60535549 306 int dom_print = 0;
ee78f405 307 bt_property_availability prop_avail;
af9a82eb 308
78cf9df6 309 event_class = bt_event_borrow_class_const(event);
37a93d41 310 stream = bt_event_borrow_stream_const(event);
10b7a2e4 311 trace = bt_stream_borrow_trace_const(stream);
9c04b633 312 ret = print_event_timestamp(pretty, event_msg, &pretty->start_line);
834e9996 313 if (ret) {
af9a82eb
JG
314 goto end;
315 }
3228cc1d 316 if (pretty->options.print_trace_field) {
c3c30b08
MD
317 const char *name;
318
10b7a2e4 319 name = bt_trace_get_name(trace);
c3c30b08 320 if (name) {
3228cc1d 321 if (!pretty->start_line) {
6e8feb63 322 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 323 }
c3c30b08 324 if (print_names) {
3228cc1d 325 print_name_equal(pretty, "trace");
c3c30b08 326 }
5280f742 327
6e8feb63 328 bt_common_g_string_append(pretty->string, name);
5280f742 329
85aa6d8f 330 if (print_names) {
6e8feb63 331 bt_common_g_string_append(pretty->string, ", ");
60535549 332 }
c3c30b08
MD
333 }
334 }
3228cc1d 335 if (pretty->options.print_trace_hostname_field) {
8eee8ea2 336 const bt_value *hostname_str;
c3c30b08 337
cd03c43c
PP
338 hostname_str = bt_trace_borrow_environment_entry_value_by_name_const(
339 trace, "hostname");
c3c30b08
MD
340 if (hostname_str) {
341 const char *str;
342
3228cc1d 343 if (!pretty->start_line) {
6e8feb63 344 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 345 }
c3c30b08 346 if (print_names) {
3228cc1d 347 print_name_equal(pretty, "trace:hostname");
c3c30b08 348 }
b5cdc106 349 str = bt_value_string_get(hostname_str);
6e8feb63 350 bt_common_g_string_append(pretty->string, str);
60535549 351 dom_print = 1;
c3c30b08
MD
352 }
353 }
3228cc1d 354 if (pretty->options.print_trace_domain_field) {
8eee8ea2 355 const bt_value *domain_str;
c3c30b08 356
cd03c43c
PP
357 domain_str = bt_trace_borrow_environment_entry_value_by_name_const(
358 trace, "domain");
c3c30b08
MD
359 if (domain_str) {
360 const char *str;
361
3228cc1d 362 if (!pretty->start_line) {
6e8feb63 363 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 364 }
c3c30b08 365 if (print_names) {
3228cc1d 366 print_name_equal(pretty, "trace:domain");
60535549 367 } else if (dom_print) {
6e8feb63 368 bt_common_g_string_append(pretty->string, ":");
c3c30b08 369 }
b5cdc106 370 str = bt_value_string_get(domain_str);
6e8feb63 371 bt_common_g_string_append(pretty->string, str);
60535549 372 dom_print = 1;
c3c30b08
MD
373 }
374 }
3228cc1d 375 if (pretty->options.print_trace_procname_field) {
8eee8ea2 376 const bt_value *procname_str;
c3c30b08 377
cd03c43c
PP
378 procname_str = bt_trace_borrow_environment_entry_value_by_name_const(
379 trace, "procname");
c3c30b08
MD
380 if (procname_str) {
381 const char *str;
382
3228cc1d 383 if (!pretty->start_line) {
6e8feb63 384 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 385 }
c3c30b08 386 if (print_names) {
3228cc1d 387 print_name_equal(pretty, "trace:procname");
60535549 388 } else if (dom_print) {
6e8feb63 389 bt_common_g_string_append(pretty->string, ":");
c3c30b08 390 }
b5cdc106 391 str = bt_value_string_get(procname_str);
6e8feb63 392 bt_common_g_string_append(pretty->string, str);
60535549 393 dom_print = 1;
c3c30b08
MD
394 }
395 }
3228cc1d 396 if (pretty->options.print_trace_vpid_field) {
8eee8ea2 397 const bt_value *vpid_value;
c3c30b08 398
cd03c43c
PP
399 vpid_value = bt_trace_borrow_environment_entry_value_by_name_const(
400 trace, "vpid");
c3c30b08
MD
401 if (vpid_value) {
402 int64_t value;
403
3228cc1d 404 if (!pretty->start_line) {
6e8feb63 405 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 406 }
c3c30b08 407 if (print_names) {
3228cc1d 408 print_name_equal(pretty, "trace:vpid");
60535549 409 } else if (dom_print) {
6e8feb63 410 bt_common_g_string_append(pretty->string, ":");
c3c30b08 411 }
60bbfc7c 412 value = bt_value_integer_signed_get(vpid_value);
275fd4d6 413 bt_common_g_string_append_printf(pretty->string,
b5cdc106 414 "(%" PRId64 ")", value);
60535549 415 dom_print = 1;
c3c30b08
MD
416 }
417 }
3228cc1d 418 if (pretty->options.print_loglevel_field) {
9cf5d083 419 static const char *log_level_names[] = {
839d52a5
PP
420 [ BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY ] = "TRACE_EMERG",
421 [ BT_EVENT_CLASS_LOG_LEVEL_ALERT ] = "TRACE_ALERT",
422 [ BT_EVENT_CLASS_LOG_LEVEL_CRITICAL ] = "TRACE_CRIT",
423 [ BT_EVENT_CLASS_LOG_LEVEL_ERROR ] = "TRACE_ERR",
424 [ BT_EVENT_CLASS_LOG_LEVEL_WARNING ] = "TRACE_WARNING",
425 [ BT_EVENT_CLASS_LOG_LEVEL_NOTICE ] = "TRACE_NOTICE",
426 [ BT_EVENT_CLASS_LOG_LEVEL_INFO ] = "TRACE_INFO",
427 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM ] = "TRACE_DEBUG_SYSTEM",
428 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM ] = "TRACE_DEBUG_PROGRAM",
429 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS ] = "TRACE_DEBUG_PROCESS",
430 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE ] = "TRACE_DEBUG_MODULE",
431 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT ] = "TRACE_DEBUG_UNIT",
432 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION ] = "TRACE_DEBUG_FUNCTION",
433 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE ] = "TRACE_DEBUG_LINE",
434 [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG ] = "TRACE_DEBUG",
9cf5d083 435 };
ee78f405 436 bt_event_class_log_level log_level;
9cf5d083
PP
437 const char *log_level_str = NULL;
438
7b33a0e0
PP
439 prop_avail = bt_event_class_get_log_level(event_class,
440 &log_level);
441 if (prop_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
9cf5d083 442 log_level_str = log_level_names[log_level];
7b33a0e0 443 BT_ASSERT(log_level_str);
c3c30b08 444
3228cc1d 445 if (!pretty->start_line) {
6e8feb63 446 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 447 }
c3c30b08 448 if (print_names) {
3228cc1d 449 print_name_equal(pretty, "loglevel");
60535549 450 } else if (dom_print) {
6e8feb63 451 bt_common_g_string_append(pretty->string, ":");
c3c30b08 452 }
9cf5d083 453
6e8feb63 454 bt_common_g_string_append(pretty->string, log_level_str);
275fd4d6 455 bt_common_g_string_append_printf(
9cf5d083 456 pretty->string, " (%d)", (int) log_level);
60535549 457 dom_print = 1;
c3c30b08
MD
458 }
459 }
3228cc1d 460 if (pretty->options.print_emf_field) {
9cf5d083 461 const char *uri_str;
c3c30b08 462
839d52a5 463 uri_str = bt_event_class_get_emf_uri(event_class);
c3c30b08 464 if (uri_str) {
3228cc1d 465 if (!pretty->start_line) {
6e8feb63 466 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 467 }
c3c30b08 468 if (print_names) {
3228cc1d 469 print_name_equal(pretty, "model.emf.uri");
60535549 470 } else if (dom_print) {
6e8feb63 471 bt_common_g_string_append(pretty->string, ":");
c3c30b08 472 }
c3c30b08 473
6e8feb63 474 bt_common_g_string_append(pretty->string, uri_str);
60535549 475 dom_print = 1;
c3c30b08
MD
476 }
477 }
60535549 478 if (dom_print && !print_names) {
6e8feb63 479 bt_common_g_string_append(pretty->string, " ");
60535549 480 }
3228cc1d 481 if (!pretty->start_line) {
6e8feb63 482 bt_common_g_string_append(pretty->string, ", ");
c3c30b08 483 }
3228cc1d 484 pretty->start_line = true;
6a18b281 485 if (print_names) {
3228cc1d 486 print_name_equal(pretty, "name");
ad96d936 487 }
b4d7c117 488 ev_name = bt_event_class_get_name(event_class);
3228cc1d 489 if (pretty->use_colors) {
b4d7c117 490 if (ev_name) {
6e8feb63
MD
491 bt_common_g_string_append(pretty->string,
492 COLOR_EVENT_NAME);
b4d7c117 493 } else {
6e8feb63
MD
494 bt_common_g_string_append(pretty->string,
495 COLOR_UNKNOWN);
b4d7c117
PP
496 }
497 }
498 if (ev_name) {
6e8feb63 499 bt_common_g_string_append(pretty->string, ev_name);
b4d7c117 500 } else {
6e8feb63 501 bt_common_g_string_append(pretty->string, "<unknown>");
6a18b281 502 }
3228cc1d 503 if (pretty->use_colors) {
6e8feb63 504 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 505 }
60535549 506 if (!print_names) {
6e8feb63 507 bt_common_g_string_append(pretty->string, ": ");
60535549 508 } else {
6e8feb63 509 bt_common_g_string_append(pretty->string, ", ");
60535549 510 }
f78d5dd1 511
af9a82eb 512end:
6a18b281
MD
513 return ret;
514}
515
516static
834e9996 517int print_integer(struct pretty_component *pretty,
8eee8ea2 518 const bt_field *field)
6a18b281 519{
834e9996 520 int ret = 0;
ee78f405 521 bt_field_class_integer_preferred_display_base base;
8eee8ea2 522 const bt_field_class *int_fc;
6a18b281
MD
523 union {
524 uint64_t u;
525 int64_t s;
526 } v;
ad96d936 527 bool rst_color = false;
ee78f405 528 bt_field_class_type ft_type;
6a18b281 529
78cf9df6 530 int_fc = bt_field_borrow_class_const(field);
939190b3 531 BT_ASSERT(int_fc);
af0c18e3
PP
532 ft_type = bt_field_get_class_type(field);
533 if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
534 ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
60bbfc7c 535 v.u = bt_field_integer_unsigned_get_value(field);
6a18b281 536 } else {
60bbfc7c 537 v.s = bt_field_integer_signed_get_value(field);
6a18b281
MD
538 }
539
3228cc1d 540 if (pretty->use_colors) {
6e8feb63 541 bt_common_g_string_append(pretty->string, COLOR_NUMBER_VALUE);
ad96d936
PP
542 rst_color = true;
543 }
544
939190b3 545 base = bt_field_class_integer_get_preferred_display_base(int_fc);
6a18b281 546 switch (base) {
939190b3 547 case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY:
6a18b281
MD
548 {
549 int bitnr, len;
550
939190b3 551 len = bt_field_class_integer_get_field_value_range(int_fc);
6e8feb63 552 bt_common_g_string_append(pretty->string, "0b");
1d0b2a8b 553 _bt_safe_lshift(v.u, 64 - len);
6a18b281 554 for (bitnr = 0; bitnr < len; bitnr++) {
b4a6d40e
MD
555 bt_common_g_string_append_c(pretty->string,
556 (v.u & (1ULL << 63)) ? '1' : '0');
1d0b2a8b 557 _bt_safe_lshift(v.u, 1);
6a18b281
MD
558 }
559 break;
560 }
939190b3 561 case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL:
6a18b281 562 {
af0c18e3
PP
563 if (ft_type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
564 ft_type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
6a18b281
MD
565 int len;
566
939190b3
PP
567 len = bt_field_class_integer_get_field_value_range(
568 int_fc);
6a18b281
MD
569 if (len < 64) {
570 size_t rounded_len;
571
8b45963b 572 BT_ASSERT(len != 0);
6a18b281
MD
573 /* Round length to the nearest 3-bit */
574 rounded_len = (((len - 1) / 3) + 1) * 3;
575 v.u &= ((uint64_t) 1 << rounded_len) - 1;
576 }
577 }
578
275fd4d6 579 bt_common_g_string_append_printf(pretty->string, "0%" PRIo64, v.u);
6a18b281
MD
580 break;
581 }
939190b3 582 case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL:
af0c18e3
PP
583 if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
584 ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
275fd4d6 585 bt_common_g_string_append_printf(pretty->string, "%" PRIu64, v.u);
6a18b281 586 } else {
275fd4d6 587 bt_common_g_string_append_printf(pretty->string, "%" PRId64, v.s);
6a18b281
MD
588 }
589 break;
939190b3 590 case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL:
6a18b281
MD
591 {
592 int len;
593
939190b3 594 len = bt_field_class_integer_get_field_value_range(int_fc);
6a18b281
MD
595 if (len < 64) {
596 /* Round length to the nearest nibble */
597 uint8_t rounded_len = ((len + 3) & ~0x3);
598
599 v.u &= ((uint64_t) 1 << rounded_len) - 1;
600 }
601
275fd4d6 602 bt_common_g_string_append_printf(pretty->string, "0x%" PRIX64, v.u);
6a18b281
MD
603 break;
604 }
605 default:
834e9996 606 ret = -1;
6a18b281
MD
607 goto end;
608 }
609end:
ad96d936 610 if (rst_color) {
6e8feb63 611 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 612 }
6a18b281
MD
613 return ret;
614}
615
93a4161c 616static
3228cc1d 617void print_escape_string(struct pretty_component *pretty, const char *str)
93a4161c
JD
618{
619 int i;
620
6e8feb63 621 bt_common_g_string_append_c(pretty->string, '"');
5280f742 622
93a4161c
JD
623 for (i = 0; i < strlen(str); i++) {
624 /* Escape sequences not recognized by iscntrl(). */
625 switch (str[i]) {
626 case '\\':
6e8feb63 627 bt_common_g_string_append(pretty->string, "\\\\");
93a4161c
JD
628 continue;
629 case '\'':
6e8feb63 630 bt_common_g_string_append(pretty->string, "\\\'");
93a4161c
JD
631 continue;
632 case '\"':
6e8feb63 633 bt_common_g_string_append(pretty->string, "\\\"");
93a4161c
JD
634 continue;
635 case '\?':
6e8feb63 636 bt_common_g_string_append(pretty->string, "\\\?");
93a4161c
JD
637 continue;
638 }
639
640 /* Standard characters. */
641 if (!iscntrl(str[i])) {
6e8feb63 642 bt_common_g_string_append_c(pretty->string, str[i]);
93a4161c
JD
643 continue;
644 }
645
646 switch (str[i]) {
647 case '\0':
6e8feb63 648 bt_common_g_string_append(pretty->string, "\\0");
93a4161c
JD
649 break;
650 case '\a':
6e8feb63 651 bt_common_g_string_append(pretty->string, "\\a");
93a4161c
JD
652 break;
653 case '\b':
6e8feb63 654 bt_common_g_string_append(pretty->string, "\\b");
93a4161c
JD
655 break;
656 case '\e':
6e8feb63 657 bt_common_g_string_append(pretty->string, "\\e");
93a4161c
JD
658 break;
659 case '\f':
6e8feb63 660 bt_common_g_string_append(pretty->string, "\\f");
93a4161c
JD
661 break;
662 case '\n':
6e8feb63 663 bt_common_g_string_append(pretty->string, "\\n");
93a4161c
JD
664 break;
665 case '\r':
6e8feb63 666 bt_common_g_string_append(pretty->string, "\\r");
93a4161c
JD
667 break;
668 case '\t':
6e8feb63 669 bt_common_g_string_append(pretty->string, "\\t");
93a4161c
JD
670 break;
671 case '\v':
6e8feb63 672 bt_common_g_string_append(pretty->string, "\\v");
93a4161c
JD
673 break;
674 default:
675 /* Unhandled control-sequence, print as hex. */
275fd4d6 676 bt_common_g_string_append_printf(pretty->string, "\\x%02x", str[i]);
93a4161c
JD
677 break;
678 }
679 }
5280f742 680
6e8feb63 681 bt_common_g_string_append_c(pretty->string, '"');
93a4161c
JD
682}
683
6a18b281 684static
834e9996 685int print_enum(struct pretty_component *pretty,
8eee8ea2 686 const bt_field *field)
6a18b281 687{
834e9996 688 int ret = 0;
8eee8ea2 689 const bt_field_class *enumeration_field_class = NULL;
939190b3 690 bt_field_class_enumeration_mapping_label_array label_array;
7b33a0e0
PP
691 uint64_t label_count;
692 uint64_t i;
96e8f959 693
78cf9df6 694 enumeration_field_class = bt_field_borrow_class_const(field);
939190b3 695 if (!enumeration_field_class) {
834e9996 696 ret = -1;
96e8f959
MD
697 goto end;
698 }
7b33a0e0 699
af0c18e3
PP
700 switch (bt_field_get_class_type(field)) {
701 case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
60bbfc7c 702 ret = bt_field_enumeration_unsigned_get_mapping_labels(field,
7b33a0e0
PP
703 &label_array, &label_count);
704 break;
af0c18e3 705 case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
60bbfc7c 706 ret = bt_field_enumeration_signed_get_mapping_labels(field,
7b33a0e0
PP
707 &label_array, &label_count);
708 break;
709 default:
710 abort();
96e8f959 711 }
7b33a0e0
PP
712
713 if (ret) {
834e9996 714 ret = -1;
96e8f959
MD
715 goto end;
716 }
7b33a0e0 717
6e8feb63 718 bt_common_g_string_append(pretty->string, "( ");
7b33a0e0 719 if (label_count == 0) {
5fb8665c 720 if (pretty->use_colors) {
6e8feb63 721 bt_common_g_string_append(pretty->string, COLOR_UNKNOWN);
5fb8665c 722 }
6e8feb63 723 bt_common_g_string_append(pretty->string, "<unknown>");
5fb8665c 724 if (pretty->use_colors) {
6e8feb63 725 bt_common_g_string_append(pretty->string, COLOR_RST);
5fb8665c
MD
726 }
727 goto skip_loop;
96e8f959 728 }
7b33a0e0
PP
729 for (i = 0; i < label_count; i++) {
730 const char *mapping_name = label_array[i];
96e8f959 731
f873b2e6 732 if (i != 0) {
6e8feb63 733 bt_common_g_string_append(pretty->string, ", ");
7b33a0e0 734 }
3228cc1d 735 if (pretty->use_colors) {
6e8feb63 736 bt_common_g_string_append(pretty->string, COLOR_ENUM_MAPPING_NAME);
ad96d936 737 }
3228cc1d
PP
738 print_escape_string(pretty, mapping_name);
739 if (pretty->use_colors) {
6e8feb63 740 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 741 }
96e8f959 742 }
5fb8665c 743skip_loop:
6e8feb63 744 bt_common_g_string_append(pretty->string, " : container = ");
a6918753 745 ret = print_integer(pretty, field);
834e9996 746 if (ret != 0) {
6a18b281
MD
747 goto end;
748 }
6e8feb63 749 bt_common_g_string_append(pretty->string, " )");
6a18b281 750end:
6a18b281
MD
751 return ret;
752}
753
754static
834e9996 755int print_struct_field(struct pretty_component *pretty,
8eee8ea2
PP
756 const bt_field *_struct,
757 const bt_field_class *struct_class,
9554ca46 758 uint64_t i, bool print_names, uint64_t *nr_printed_fields)
6a18b281 759{
834e9996 760 int ret = 0;
6a18b281 761 const char *field_name;
8eee8ea2 762 const bt_field *field = NULL;
e24f271a 763 const bt_field_class_structure_member *member;
6a18b281 764
78cf9df6 765 field = bt_field_structure_borrow_member_field_by_index_const(_struct, i);
6a18b281 766 if (!field) {
834e9996 767 ret = -1;
6a18b281
MD
768 goto end;
769 }
7b33a0e0 770
e24f271a
PP
771 member = bt_field_class_structure_borrow_member_by_index_const(
772 struct_class, i);
773 field_name = bt_field_class_structure_member_get_name(member);
6a18b281 774
2b4c4a7c 775 if (*nr_printed_fields > 0) {
6e8feb63 776 bt_common_g_string_append(pretty->string, ", ");
6a18b281 777 } else {
6e8feb63 778 bt_common_g_string_append(pretty->string, " ");
6a18b281
MD
779 }
780 if (print_names) {
a153db48 781 print_field_name_equal(pretty, field_name);
6a18b281 782 }
9554ca46 783 ret = print_field(pretty, field, print_names);
2b4c4a7c 784 *nr_printed_fields += 1;
f78d5dd1 785
6a18b281 786end:
6a18b281
MD
787 return ret;
788}
789
790static
834e9996 791int print_struct(struct pretty_component *pretty,
9554ca46 792 const bt_field *_struct, bool print_names)
6a18b281 793{
834e9996 794 int ret = 0;
8eee8ea2 795 const bt_field_class *struct_class = NULL;
7b33a0e0 796 uint64_t nr_fields, i, nr_printed_fields;
6a18b281 797
78cf9df6 798 struct_class = bt_field_borrow_class_const(_struct);
939190b3 799 if (!struct_class) {
834e9996 800 ret = -1;
6a18b281
MD
801 goto end;
802 }
33c3d106 803
939190b3 804 nr_fields = bt_field_class_structure_get_member_count(struct_class);
33c3d106 805
6e8feb63 806 bt_common_g_string_append(pretty->string, "{");
3228cc1d 807 pretty->depth++;
2b4c4a7c 808 nr_printed_fields = 0;
6a18b281 809 for (i = 0; i < nr_fields; i++) {
939190b3 810 ret = print_struct_field(pretty, _struct, struct_class, i,
9554ca46 811 print_names, &nr_printed_fields);
834e9996 812 if (ret != 0) {
6a18b281
MD
813 goto end;
814 }
815 }
3228cc1d 816 pretty->depth--;
6e8feb63 817 bt_common_g_string_append(pretty->string, " }");
f78d5dd1 818
6a18b281 819end:
6a18b281
MD
820 return ret;
821}
822
823static
834e9996 824int print_array_field(struct pretty_component *pretty,
8eee8ea2 825 const bt_field *array, uint64_t i, bool print_names)
6a18b281 826{
8eee8ea2 827 const bt_field *field = NULL;
6a18b281 828
7b33a0e0 829 if (i != 0) {
6e8feb63 830 bt_common_g_string_append(pretty->string, ", ");
7b33a0e0 831 } else {
6e8feb63 832 bt_common_g_string_append(pretty->string, " ");
6a18b281 833 }
7b33a0e0 834 if (print_names) {
275fd4d6 835 bt_common_g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
6a18b281 836 }
f78d5dd1 837
78cf9df6 838 field = bt_field_array_borrow_element_field_by_index_const(array, i);
7b33a0e0 839 BT_ASSERT(field);
9554ca46 840 return print_field(pretty, field, print_names);
6a18b281
MD
841}
842
843static
834e9996 844int print_array(struct pretty_component *pretty,
8eee8ea2 845 const bt_field *array, bool print_names)
6a18b281 846{
834e9996 847 int ret = 0;
8eee8ea2 848 const bt_field_class *array_class = NULL;
7b33a0e0 849 uint64_t len;
6a18b281 850 uint64_t i;
6a18b281 851
78cf9df6 852 array_class = bt_field_borrow_class_const(array);
939190b3 853 if (!array_class) {
834e9996 854 ret = -1;
6a18b281
MD
855 goto end;
856 }
7b33a0e0 857 len = bt_field_array_get_length(array);
6e8feb63 858 bt_common_g_string_append(pretty->string, "[");
3228cc1d 859 pretty->depth++;
6a18b281 860 for (i = 0; i < len; i++) {
7b33a0e0 861 ret = print_array_field(pretty, array, i, print_names);
834e9996 862 if (ret != 0) {
6a18b281
MD
863 goto end;
864 }
865 }
3228cc1d 866 pretty->depth--;
6e8feb63 867 bt_common_g_string_append(pretty->string, " ]");
f78d5dd1 868
6a18b281 869end:
6a18b281
MD
870 return ret;
871}
872
873static
834e9996 874int print_sequence_field(struct pretty_component *pretty,
8eee8ea2 875 const bt_field *seq, uint64_t i, bool print_names)
6a18b281 876{
8eee8ea2 877 const bt_field *field = NULL;
6a18b281 878
7b33a0e0 879 if (i != 0) {
6e8feb63 880 bt_common_g_string_append(pretty->string, ", ");
7b33a0e0 881 } else {
6e8feb63 882 bt_common_g_string_append(pretty->string, " ");
6a18b281 883 }
7b33a0e0 884 if (print_names) {
275fd4d6 885 bt_common_g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
6a18b281 886 }
f78d5dd1 887
78cf9df6 888 field = bt_field_array_borrow_element_field_by_index_const(seq, i);
7b33a0e0 889 BT_ASSERT(field);
9554ca46 890 return print_field(pretty, field, print_names);
6a18b281
MD
891}
892
893static
834e9996 894int print_sequence(struct pretty_component *pretty,
8eee8ea2 895 const bt_field *seq, bool print_names)
6a18b281 896{
834e9996 897 int ret = 0;
7b33a0e0 898 uint64_t len;
6a18b281 899 uint64_t i;
6a18b281 900
7b33a0e0 901 len = bt_field_array_get_length(seq);
6e8feb63 902 bt_common_g_string_append(pretty->string, "[");
6a18b281 903
3228cc1d 904 pretty->depth++;
6a18b281 905 for (i = 0; i < len; i++) {
7b33a0e0 906 ret = print_sequence_field(pretty, seq, i, print_names);
834e9996 907 if (ret != 0) {
6a18b281
MD
908 goto end;
909 }
910 }
3228cc1d 911 pretty->depth--;
6e8feb63 912 bt_common_g_string_append(pretty->string, " ]");
f78d5dd1 913
6a18b281 914end:
6a18b281
MD
915 return ret;
916}
917
4a9cfc40
PP
918static
919int print_option(struct pretty_component *pretty,
920 const bt_field *option, bool print_names)
921{
922 int ret = 0;
923 const bt_field *field = NULL;
924
925 field = bt_field_option_borrow_field_const(option);
926 if (field) {
927 bt_common_g_string_append(pretty->string, "{ ");
928 pretty->depth++;
929 if (print_names) {
930 // TODO: find tag's name using field path
931 // print_field_name_equal(pretty, tag_choice);
932 }
933 ret = print_field(pretty, field, print_names);
934 if (ret != 0) {
935 goto end;
936 }
937 pretty->depth--;
938 bt_common_g_string_append(pretty->string, " }");
939 } else {
940 bt_common_g_string_append(pretty->string, "<none>");
941 }
942
943end:
944 return ret;
945}
946
6a18b281 947static
834e9996 948int print_variant(struct pretty_component *pretty,
8eee8ea2 949 const bt_field *variant, bool print_names)
6a18b281 950{
834e9996 951 int ret = 0;
8eee8ea2 952 const bt_field *field = NULL;
6a18b281 953
78cf9df6 954 field = bt_field_variant_borrow_selected_option_field_const(variant);
7b33a0e0 955 BT_ASSERT(field);
6e8feb63 956 bt_common_g_string_append(pretty->string, "{ ");
3228cc1d 957 pretty->depth++;
6a18b281 958 if (print_names) {
7b33a0e0
PP
959 // TODO: find tag's name using field path
960 // print_field_name_equal(pretty, tag_choice);
6a18b281 961 }
9554ca46 962 ret = print_field(pretty, field, print_names);
834e9996 963 if (ret != 0) {
6a18b281
MD
964 goto end;
965 }
3228cc1d 966 pretty->depth--;
6e8feb63 967 bt_common_g_string_append(pretty->string, " }");
f78d5dd1 968
6a18b281 969end:
6a18b281
MD
970 return ret;
971}
972
973static
834e9996 974int print_field(struct pretty_component *pretty,
9554ca46 975 const bt_field *field, bool print_names)
6a18b281 976{
ee78f405 977 bt_field_class_type class_id;
6a18b281 978
af0c18e3 979 class_id = bt_field_get_class_type(field);
939190b3 980 switch (class_id) {
4a9029cb
PP
981 case BT_FIELD_CLASS_TYPE_BOOL:
982 {
983 bt_bool v;
984 const char *text;
985
986 v = bt_field_bool_get_value(field);
987 if (pretty->use_colors) {
988 bt_common_g_string_append(pretty->string, COLOR_NUMBER_VALUE);
989 }
990 if (v) {
991 text = "true";
992 } else {
993 text = "false";
994 }
995 bt_common_g_string_append(pretty->string, text);
996 if (pretty->use_colors) {
997 bt_common_g_string_append(pretty->string, COLOR_RST);
998 }
999 return 0;
1000 }
be5a0221
PP
1001 case BT_FIELD_CLASS_TYPE_BIT_ARRAY:
1002 {
1003 uint64_t v = bt_field_bit_array_get_value_as_integer(field);
1004
1005 if (pretty->use_colors) {
1006 bt_common_g_string_append(pretty->string,
1007 COLOR_NUMBER_VALUE);
1008 }
1009 bt_common_g_string_append_printf(pretty->string, "0x%" PRIX64,
1010 v);
1011 if (pretty->use_colors) {
1012 bt_common_g_string_append(pretty->string, COLOR_RST);
1013 }
1014 return 0;
1015 }
af0c18e3
PP
1016 case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
1017 case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
3228cc1d 1018 return print_integer(pretty, field);
76276a81
FD
1019 case BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL:
1020 case BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL:
6a18b281
MD
1021 {
1022 double v;
1023
76276a81
FD
1024 if (class_id == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
1025 v = (float) bt_field_real_single_precision_get_value(field);
1026 } else {
1027 v = bt_field_real_double_precision_get_value(field);
1028 }
1029
3228cc1d 1030 if (pretty->use_colors) {
6e8feb63 1031 bt_common_g_string_append(pretty->string, COLOR_NUMBER_VALUE);
ad96d936 1032 }
275fd4d6 1033 bt_common_g_string_append_printf(pretty->string, "%g", v);
3228cc1d 1034 if (pretty->use_colors) {
6e8feb63 1035 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 1036 }
834e9996 1037 return 0;
6a18b281 1038 }
af0c18e3
PP
1039 case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
1040 case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
3228cc1d 1041 return print_enum(pretty, field);
af0c18e3 1042 case BT_FIELD_CLASS_TYPE_STRING:
d1f0e0e3
JG
1043 {
1044 const char *str;
1045
839d52a5 1046 str = bt_field_string_get_value(field);
d1f0e0e3 1047 if (!str) {
834e9996 1048 return -1;
d1f0e0e3
JG
1049 }
1050
3228cc1d 1051 if (pretty->use_colors) {
6e8feb63 1052 bt_common_g_string_append(pretty->string, COLOR_STRING_VALUE);
ad96d936 1053 }
d1f0e0e3 1054 print_escape_string(pretty, str);
3228cc1d 1055 if (pretty->use_colors) {
6e8feb63 1056 bt_common_g_string_append(pretty->string, COLOR_RST);
ad96d936 1057 }
834e9996 1058 return 0;
d1f0e0e3 1059 }
af0c18e3 1060 case BT_FIELD_CLASS_TYPE_STRUCTURE:
9554ca46 1061 return print_struct(pretty, field, print_names);
467673c1
PP
1062 case BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR:
1063 case BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR:
1064 case BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR:
1065 case BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR:
4a9cfc40 1066 return print_option(pretty, field, print_names);
02b61fe0 1067 case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR:
0822832b
PP
1068 case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR:
1069 case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR:
3228cc1d 1070 return print_variant(pretty, field, print_names);
af0c18e3 1071 case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
3228cc1d 1072 return print_array(pretty, field, print_names);
af0c18e3 1073 case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
3228cc1d 1074 return print_sequence(pretty, field, print_names);
6a18b281 1075 default:
5280f742 1076 // TODO: log instead
939190b3 1077 fprintf(pretty->err, "[error] Unknown type id: %d\n", (int) class_id);
834e9996 1078 return -1;
6a18b281
MD
1079 }
1080}
1081
1082static
834e9996 1083int print_stream_packet_context(struct pretty_component *pretty,
8eee8ea2 1084 const bt_event *event)
6a18b281 1085{
834e9996 1086 int ret = 0;
8eee8ea2
PP
1087 const bt_packet *packet = NULL;
1088 const bt_field *main_field = NULL;
6a18b281 1089
78cf9df6 1090 packet = bt_event_borrow_packet_const(event);
6a18b281 1091 if (!packet) {
6a18b281
MD
1092 goto end;
1093 }
78cf9df6 1094 main_field = bt_packet_borrow_context_field_const(packet);
6a18b281 1095 if (!main_field) {
6a18b281
MD
1096 goto end;
1097 }
3228cc1d 1098 if (!pretty->start_line) {
6e8feb63 1099 bt_common_g_string_append(pretty->string, ", ");
6e1bc0df 1100 }
3228cc1d
PP
1101 pretty->start_line = false;
1102 if (pretty->options.print_scope_field_names) {
1103 print_name_equal(pretty, "stream.packet.context");
6a18b281 1104 }
3228cc1d 1105 ret = print_field(pretty, main_field,
9554ca46 1106 pretty->options.print_context_field_names);
f78d5dd1 1107
6a18b281 1108end:
6a18b281
MD
1109 return ret;
1110}
1111
6a18b281 1112static
834e9996 1113int print_stream_event_context(struct pretty_component *pretty,
8eee8ea2 1114 const bt_event *event)
6a18b281 1115{
834e9996 1116 int ret = 0;
8eee8ea2 1117 const bt_field *main_field = NULL;
6a18b281 1118
78cf9df6 1119 main_field = bt_event_borrow_common_context_field_const(event);
6a18b281 1120 if (!main_field) {
6a18b281
MD
1121 goto end;
1122 }
3228cc1d 1123 if (!pretty->start_line) {
6e8feb63 1124 bt_common_g_string_append(pretty->string, ", ");
6e1bc0df 1125 }
3228cc1d
PP
1126 pretty->start_line = false;
1127 if (pretty->options.print_scope_field_names) {
1128 print_name_equal(pretty, "stream.event.context");
6a18b281 1129 }
3228cc1d 1130 ret = print_field(pretty, main_field,
9554ca46 1131 pretty->options.print_context_field_names);
f78d5dd1 1132
6a18b281 1133end:
6a18b281
MD
1134 return ret;
1135}
1136
1137static
834e9996 1138int print_event_context(struct pretty_component *pretty,
8eee8ea2 1139 const bt_event *event)
6a18b281 1140{
834e9996 1141 int ret = 0;
8eee8ea2 1142 const bt_field *main_field = NULL;
6a18b281 1143
78cf9df6 1144 main_field = bt_event_borrow_specific_context_field_const(event);
6a18b281 1145 if (!main_field) {
6a18b281
MD
1146 goto end;
1147 }
3228cc1d 1148 if (!pretty->start_line) {
6e8feb63 1149 bt_common_g_string_append(pretty->string, ", ");
6e1bc0df 1150 }
3228cc1d
PP
1151 pretty->start_line = false;
1152 if (pretty->options.print_scope_field_names) {
1153 print_name_equal(pretty, "event.context");
6a18b281 1154 }
3228cc1d 1155 ret = print_field(pretty, main_field,
9554ca46 1156 pretty->options.print_context_field_names);
f78d5dd1 1157
6a18b281 1158end:
6a18b281
MD
1159 return ret;
1160}
1161
1162static
834e9996 1163int print_event_payload(struct pretty_component *pretty,
8eee8ea2 1164 const bt_event *event)
6a18b281 1165{
834e9996 1166 int ret = 0;
8eee8ea2 1167 const bt_field *main_field = NULL;
6a18b281 1168
78cf9df6 1169 main_field = bt_event_borrow_payload_field_const(event);
6a18b281 1170 if (!main_field) {
6a18b281
MD
1171 goto end;
1172 }
3228cc1d 1173 if (!pretty->start_line) {
6e8feb63 1174 bt_common_g_string_append(pretty->string, ", ");
6e1bc0df 1175 }
3228cc1d
PP
1176 pretty->start_line = false;
1177 if (pretty->options.print_scope_field_names) {
1178 print_name_equal(pretty, "event.fields");
6a18b281 1179 }
3228cc1d 1180 ret = print_field(pretty, main_field,
9554ca46 1181 pretty->options.print_payload_field_names);
f78d5dd1 1182
6a18b281 1183end:
af9a82eb
JG
1184 return ret;
1185}
1186
da6febac 1187static
1e3d9900 1188int flush_buf(FILE *stream, struct pretty_component *pretty)
da6febac
PP
1189{
1190 int ret = 0;
1191
1192 if (pretty->string->len == 0) {
1193 goto end;
1194 }
1195
1e3d9900 1196 if (fwrite(pretty->string->str, pretty->string->len, 1, stream) != 1) {
da6febac
PP
1197 ret = -1;
1198 }
1199
1200end:
1201 return ret;
1202}
1203
af9a82eb 1204BT_HIDDEN
834e9996 1205int pretty_print_event(struct pretty_component *pretty,
b09a5592 1206 const bt_message *event_msg)
af9a82eb 1207{
834e9996 1208 int ret;
8eee8ea2 1209 const bt_event *event =
b09a5592 1210 bt_message_event_borrow_event_const(event_msg);
af9a82eb 1211
8b45963b 1212 BT_ASSERT(event);
3228cc1d 1213 pretty->start_line = true;
5280f742 1214 g_string_assign(pretty->string, "");
9c04b633 1215 ret = print_event_header(pretty, event_msg);
834e9996 1216 if (ret != 0) {
af9a82eb
JG
1217 goto end;
1218 }
6a18b281 1219
3228cc1d 1220 ret = print_stream_packet_context(pretty, event);
834e9996 1221 if (ret != 0) {
6a18b281
MD
1222 goto end;
1223 }
6a18b281 1224
3228cc1d 1225 ret = print_stream_event_context(pretty, event);
834e9996 1226 if (ret != 0) {
6a18b281
MD
1227 goto end;
1228 }
6a18b281 1229
3228cc1d 1230 ret = print_event_context(pretty, event);
834e9996 1231 if (ret != 0) {
6a18b281
MD
1232 goto end;
1233 }
6a18b281 1234
3228cc1d 1235 ret = print_event_payload(pretty, event);
834e9996 1236 if (ret != 0) {
6a18b281
MD
1237 goto end;
1238 }
af9a82eb 1239
6e8feb63 1240 bt_common_g_string_append_c(pretty->string, '\n');
1e3d9900 1241 if (flush_buf(pretty->out, pretty)) {
834e9996 1242 ret = -1;
5280f742
PP
1243 goto end;
1244 }
1245
af9a82eb
JG
1246end:
1247 return ret;
1248}
1e3d9900
PP
1249
1250static
22dfa677
PP
1251int print_discarded_elements_msg(struct pretty_component *pretty,
1252 const bt_stream *stream,
1253 const bt_clock_snapshot *begin_clock_snapshot,
1254 const bt_clock_snapshot *end_clock_snapshot,
1e3d9900
PP
1255 uint64_t count, const char *elem_type)
1256{
834e9996 1257 int ret = 0;
8eee8ea2
PP
1258 const bt_stream_class *stream_class = NULL;
1259 const bt_trace *trace = NULL;
1e3d9900
PP
1260 const char *stream_name;
1261 const char *trace_name;
22dfa677 1262 bt_uuid trace_uuid;
1e3d9900
PP
1263 int64_t stream_class_id;
1264 int64_t stream_id;
2d92a1f4 1265 const char *init_msg;
1e3d9900
PP
1266
1267 /* Stream name */
1e3d9900 1268 stream_name = bt_stream_get_name(stream);
22dfa677
PP
1269 if (!stream_name) {
1270 stream_name = "(unknown)";
1271 }
1e3d9900
PP
1272
1273 /* Stream class ID */
78cf9df6 1274 stream_class = bt_stream_borrow_class_const(stream);
1e3d9900
PP
1275 BT_ASSERT(stream_class);
1276 stream_class_id = bt_stream_class_get_id(stream_class);
1277
1278 /* Stream ID */
1279 stream_id = bt_stream_get_id(stream);
1280
1281 /* Trace name */
22dfa677 1282 trace = bt_stream_borrow_trace_const(stream);
1e3d9900
PP
1283 BT_ASSERT(trace);
1284 trace_name = bt_trace_get_name(trace);
1285 if (!trace_name) {
1286 trace_name = "(unknown)";
1287 }
1288
1289 /* Trace UUID */
cd03c43c 1290 trace_uuid = bt_trace_get_uuid(trace);
1e3d9900
PP
1291
1292 /* Format message */
1293 g_string_assign(pretty->string, "");
2d92a1f4
PP
1294
1295 if (count == UINT64_C(-1)) {
1296 init_msg = "Tracer may have discarded";
1297 } else {
1298 init_msg = "Tracer discarded";
1299 }
1300
275fd4d6 1301 bt_common_g_string_append_printf(pretty->string,
2d92a1f4 1302 "%s%sWARNING%s%s: %s ",
1e3d9900
PP
1303 bt_common_color_fg_yellow(),
1304 bt_common_color_bold(),
1305 bt_common_color_reset(),
2d92a1f4 1306 bt_common_color_fg_yellow(), init_msg);
22dfa677
PP
1307
1308 if (count == UINT64_C(-1)) {
275fd4d6 1309 bt_common_g_string_append_printf(pretty->string, "%ss", elem_type);
22dfa677 1310 } else {
275fd4d6 1311 bt_common_g_string_append_printf(pretty->string,
22dfa677
PP
1312 "%" PRIu64 " %s%s", count, elem_type,
1313 count == 1 ? "" : "s");
1314 }
1e3d9900 1315
6e8feb63 1316 bt_common_g_string_append_c(pretty->string, ' ');
34f2b0fb 1317
ecbb78c0 1318 if (begin_clock_snapshot && end_clock_snapshot) {
6e8feb63 1319 bt_common_g_string_append(pretty->string, "between [");
029ba264 1320 print_timestamp_wall(pretty, begin_clock_snapshot, false);
6e8feb63 1321 bt_common_g_string_append(pretty->string, "] and [");
029ba264 1322 print_timestamp_wall(pretty, end_clock_snapshot, false);
6e8feb63 1323 bt_common_g_string_append(pretty->string, "]");
1e3d9900 1324 } else {
6e8feb63 1325 bt_common_g_string_append(pretty->string, "(unknown time range)");
1e3d9900
PP
1326 }
1327
275fd4d6 1328 bt_common_g_string_append_printf(pretty->string, " in trace \"%s\" ", trace_name);
1e3d9900
PP
1329
1330 if (trace_uuid) {
275fd4d6 1331 bt_common_g_string_append_printf(pretty->string,
d126826c
MJ
1332 "(UUID: " BT_UUID_FMT ") ",
1333 BT_UUID_FMT_VALUES(trace_uuid));
1e3d9900 1334 } else {
6e8feb63 1335 bt_common_g_string_append(pretty->string, "(no UUID) ");
1e3d9900
PP
1336 }
1337
275fd4d6 1338 bt_common_g_string_append_printf(pretty->string,
22dfa677 1339 "within stream \"%s\" (stream class ID: %" PRIu64 ", ",
1e3d9900
PP
1340 stream_name, stream_class_id);
1341
1342 if (stream_id >= 0) {
275fd4d6 1343 bt_common_g_string_append_printf(pretty->string,
22dfa677 1344 "stream ID: %" PRIu64, stream_id);
1e3d9900 1345 } else {
6e8feb63 1346 bt_common_g_string_append(pretty->string, "no stream ID");
1e3d9900
PP
1347 }
1348
275fd4d6 1349 bt_common_g_string_append_printf(pretty->string, ").%s\n",
1e3d9900
PP
1350 bt_common_color_reset());
1351
1352 /*
1353 * Print to standard error stream to remain backward compatible
1354 * with Babeltrace 1.
1355 */
1356 if (flush_buf(stderr, pretty)) {
834e9996 1357 ret = -1;
1e3d9900
PP
1358 }
1359
1360 return ret;
1361}
1362
1363BT_HIDDEN
22dfa677
PP
1364int pretty_print_discarded_items(struct pretty_component *pretty,
1365 const bt_message *msg)
1e3d9900 1366{
22dfa677
PP
1367 const bt_clock_snapshot *begin = NULL;
1368 const bt_clock_snapshot *end = NULL;
1369 const bt_stream *stream;
1370 const bt_stream_class *stream_class;
1371 uint64_t count = UINT64_C(-1);
1372 const char *elem_type;
1373
1374 switch (bt_message_get_type(msg)) {
1375 case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
1376 stream = bt_message_discarded_events_borrow_stream_const(msg);
1377
1378 if (bt_message_discarded_events_get_count(msg, &count) ==
1379 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1380 count = UINT64_C(-1);
1e3d9900 1381 }
22dfa677
PP
1382
1383 elem_type = "event";
1384 break;
1385 case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
1386 stream = bt_message_discarded_packets_borrow_stream_const(msg);
1387
1388 if (bt_message_discarded_packets_get_count(msg, &count) ==
1389 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1390 count = UINT64_C(-1);
1391 }
1392
1393 elem_type = "packet";
1394 break;
1395 default:
1396 abort();
1e3d9900
PP
1397 }
1398
22dfa677
PP
1399 BT_ASSERT(stream);
1400 stream_class = bt_stream_borrow_class_const(stream);
1401
77037b2b
PP
1402 switch (bt_message_get_type(msg)) {
1403 case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
1404 if (bt_stream_class_discarded_events_have_default_clock_snapshots(
1405 stream_class)) {
5ef34326 1406 begin = bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
11ddb3ef 1407 msg);
5ef34326 1408 end = bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
11ddb3ef 1409 msg);
77037b2b
PP
1410 }
1411
1412 break;
1413 case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
1414 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(
1415 stream_class)) {
5ef34326 1416 begin = bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
11ddb3ef 1417 msg);
5ef34326 1418 end = bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
11ddb3ef 1419 msg);
1e3d9900 1420 }
77037b2b
PP
1421
1422 break;
1423 default:
1424 abort();
1e3d9900
PP
1425 }
1426
22dfa677
PP
1427 print_discarded_elements_msg(pretty, stream, begin, end,
1428 count, elem_type);
7b33a0e0 1429 return 0;
1e3d9900 1430}
This page took 0.157139 seconds and 4 git commands to generate.