src/plugins/text/pretty/print.c

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