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_stream_class *stream_class = NULL;
 299         const bt_trace_class *trace_class = NULL;
 300         const bt_packet *packet = NULL;
 301         const bt_stream *stream = NULL;
 302         const bt_trace *trace = NULL;
 303         const bt_event *event = bt_message_event_borrow_event_const(event_msg);
 304         const char *ev_name;
 305         int dom_print = 0;
 306         bt_property_availability prop_avail;
 307
 308         event_class = bt_event_borrow_class_const(event);
 309         stream_class = bt_event_class_borrow_stream_class_const(event_class);
 310         trace_class = bt_stream_class_borrow_trace_class_const(stream_class);
 311         packet = bt_event_borrow_packet_const(event);
 312         stream = bt_packet_borrow_stream_const(packet);
 313         trace = bt_stream_borrow_trace_const(stream);
 314         ret = print_event_timestamp(pretty, event_msg, &pretty->start_line);
 315         if (ret) {
 316                 goto end;
 317         }
 318         if (pretty->options.print_trace_field) {
 319                 const char *name;
 320
 321                 name = bt_trace_get_name(trace);
 322                 if (name) {
 323                         if (!pretty->start_line) {
 324                                 g_string_append(pretty->string, ", ");
 325                         }
 326                         if (print_names) {
 327                                 print_name_equal(pretty, "trace");
 328                         }
 329
 330                         g_string_append(pretty->string, name);
 331
 332                         if (print_names) {
 333                                 g_string_append(pretty->string, ", ");
 334                         }
 335                 }
 336         }
 337         if (pretty->options.print_trace_hostname_field) {
 338                 const bt_value *hostname_str;
 339
 340                 hostname_str = bt_trace_class_borrow_environment_entry_value_by_name_const(
 341                         trace_class, "hostname");
 342                 if (hostname_str) {
 343                         const char *str;
 344
 345                         if (!pretty->start_line) {
 346                                 g_string_append(pretty->string, ", ");
 347                         }
 348                         if (print_names) {
 349                                 print_name_equal(pretty, "trace:hostname");
 350                         }
 351                         str = bt_value_string_get(hostname_str);
 352                         g_string_append(pretty->string, str);
 353                         dom_print = 1;
 354                 }
 355         }
 356         if (pretty->options.print_trace_domain_field) {
 357                 const bt_value *domain_str;
 358
 359                 domain_str = bt_trace_class_borrow_environment_entry_value_by_name_const(
 360                         trace_class, "domain");
 361                 if (domain_str) {
 362                         const char *str;
 363
 364                         if (!pretty->start_line) {
 365                                 g_string_append(pretty->string, ", ");
 366                         }
 367                         if (print_names) {
 368                                 print_name_equal(pretty, "trace:domain");
 369                         } else if (dom_print) {
 370                                 g_string_append(pretty->string, ":");
 371                         }
 372                         str = bt_value_string_get(domain_str);
 373                         g_string_append(pretty->string, str);
 374                         dom_print = 1;
 375                 }
 376         }
 377         if (pretty->options.print_trace_procname_field) {
 378                 const bt_value *procname_str;
 379
 380                 procname_str = bt_trace_class_borrow_environment_entry_value_by_name_const(
 381                         trace_class, "procname");
 382                 if (procname_str) {
 383                         const char *str;
 384
 385                         if (!pretty->start_line) {
 386                                 g_string_append(pretty->string, ", ");
 387                         }
 388                         if (print_names) {
 389                                 print_name_equal(pretty, "trace:procname");
 390                         } else if (dom_print) {
 391                                 g_string_append(pretty->string, ":");
 392                         }
 393                         str = bt_value_string_get(procname_str);
 394                         g_string_append(pretty->string, str);
 395                         dom_print = 1;
 396                 }
 397         }
 398         if (pretty->options.print_trace_vpid_field) {
 399                 const bt_value *vpid_value;
 400
 401                 vpid_value = bt_trace_class_borrow_environment_entry_value_by_name_const(
 402                         trace_class, "vpid");
 403                 if (vpid_value) {
 404                         int64_t value;
 405
 406                         if (!pretty->start_line) {
 407                                 g_string_append(pretty->string, ", ");
 408                         }
 409                         if (print_names) {
 410                                 print_name_equal(pretty, "trace:vpid");
 411                         } else if (dom_print) {
 412                                 g_string_append(pretty->string, ":");
 413                         }
 414                         value = bt_value_signed_integer_get(vpid_value);
 415                         g_string_append_printf(pretty->string,
 416                                 "(%" PRId64 ")", value);
 417                         dom_print = 1;
 418                 }
 419         }
 420         if (pretty->options.print_loglevel_field) {
 421                 static const char *log_level_names[] = {
 422                         [ BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY ] = "TRACE_EMERG",
 423                         [ BT_EVENT_CLASS_LOG_LEVEL_ALERT ] = "TRACE_ALERT",
 424                         [ BT_EVENT_CLASS_LOG_LEVEL_CRITICAL ] = "TRACE_CRIT",
 425                         [ BT_EVENT_CLASS_LOG_LEVEL_ERROR ] = "TRACE_ERR",
 426                         [ BT_EVENT_CLASS_LOG_LEVEL_WARNING ] = "TRACE_WARNING",
 427                         [ BT_EVENT_CLASS_LOG_LEVEL_NOTICE ] = "TRACE_NOTICE",
 428                         [ BT_EVENT_CLASS_LOG_LEVEL_INFO ] = "TRACE_INFO",
 429                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM ] = "TRACE_DEBUG_SYSTEM",
 430                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM ] = "TRACE_DEBUG_PROGRAM",
 431                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS ] = "TRACE_DEBUG_PROCESS",
 432                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE ] = "TRACE_DEBUG_MODULE",
 433                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT ] = "TRACE_DEBUG_UNIT",
 434                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION ] = "TRACE_DEBUG_FUNCTION",
 435                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE ] = "TRACE_DEBUG_LINE",
 436                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG ] = "TRACE_DEBUG",
 437                 };
 438                 bt_event_class_log_level log_level;
 439                 const char *log_level_str = NULL;
 440
 441                 prop_avail = bt_event_class_get_log_level(event_class,
 442                         &log_level);
 443                 if (prop_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 444                         log_level_str = log_level_names[log_level];
 445                         BT_ASSERT(log_level_str);
 446
 447                         if (!pretty->start_line) {
 448                                 g_string_append(pretty->string, ", ");
 449                         }
 450                         if (print_names) {
 451                                 print_name_equal(pretty, "loglevel");
 452                         } else if (dom_print) {
 453                                 g_string_append(pretty->string, ":");
 454                         }
 455
 456                         g_string_append(pretty->string, log_level_str);
 457                         g_string_append_printf(
 458                                 pretty->string, " (%d)", (int) log_level);
 459                         dom_print = 1;
 460                 }
 461         }
 462         if (pretty->options.print_emf_field) {
 463                 const char *uri_str;
 464
 465                 uri_str = bt_event_class_get_emf_uri(event_class);
 466                 if (uri_str) {
 467                         if (!pretty->start_line) {
 468                                 g_string_append(pretty->string, ", ");
 469                         }
 470                         if (print_names) {
 471                                 print_name_equal(pretty, "model.emf.uri");
 472                         } else if (dom_print) {
 473                                 g_string_append(pretty->string, ":");
 474                         }
 475
 476                         g_string_append(pretty->string, uri_str);
 477                         dom_print = 1;
 478                 }
 479         }
 480         if (dom_print && !print_names) {
 481                 g_string_append(pretty->string, " ");
 482         }
 483         if (!pretty->start_line) {
 484                 g_string_append(pretty->string, ", ");
 485         }
 486         pretty->start_line = true;
 487         if (print_names) {
 488                 print_name_equal(pretty, "name");
 489         }
 490         ev_name = bt_event_class_get_name(event_class);
 491         if (pretty->use_colors) {
 492                 if (ev_name) {
 493                         g_string_append(pretty->string, COLOR_EVENT_NAME);
 494                 } else {
 495                         g_string_append(pretty->string, COLOR_UNKNOWN);
 496                 }
 497         }
 498         if (ev_name) {
 499                 g_string_append(pretty->string, ev_name);
 500         } else {
 501                 g_string_append(pretty->string, "<unknown>");
 502         }
 503         if (pretty->use_colors) {
 504                 g_string_append(pretty->string, COLOR_RST);
 505         }
 506         if (!print_names) {
 507                 g_string_append(pretty->string, ": ");
 508         } else {
 509                 g_string_append(pretty->string, ", ");
 510         }
 511
 512 end:
 513         return ret;
 514 }
 515
 516 static
 517 int print_integer(struct pretty_component *pretty,
 518                 const bt_field *field)
 519 {
 520         int ret = 0;
 521         bt_field_class_integer_preferred_display_base base;
 522         const bt_field_class *int_fc;
 523         union {
 524                 uint64_t u;
 525                 int64_t s;
 526         } v;
 527         bool rst_color = false;
 528         bt_field_class_type ft_type;
 529
 530         int_fc = bt_field_borrow_class_const(field);
 531         BT_ASSERT(int_fc);
 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) {
 535                 v.u = bt_field_unsigned_integer_get_value(field);
 536         } else {
 537                 v.s = bt_field_signed_integer_get_value(field);
 538         }
 539
 540         if (pretty->use_colors) {
 541                 g_string_append(pretty->string, COLOR_NUMBER_VALUE);
 542                 rst_color = true;
 543         }
 544
 545         base = bt_field_class_integer_get_preferred_display_base(int_fc);
 546         switch (base) {
 547         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY:
 548         {
 549                 int bitnr, len;
 550
 551                 len = bt_field_class_integer_get_field_value_range(int_fc);
 552                 g_string_append(pretty->string, "0b");
 553                 _bt_safe_lshift(v.u, 64 - len);
 554                 for (bitnr = 0; bitnr < len; bitnr++) {
 555                         g_string_append_printf(pretty->string, "%u", (v.u & (1ULL << 63)) ? 1 : 0);
 556                         _bt_safe_lshift(v.u, 1);
 557                 }
 558                 break;
 559         }
 560         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL:
 561         {
 562                 if (ft_type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
 563                                 ft_type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
 564                         int len;
 565
 566                         len = bt_field_class_integer_get_field_value_range(
 567                                 int_fc);
 568                         if (len < 64) {
 569                                 size_t rounded_len;
 570
 571                                 BT_ASSERT(len != 0);
 572                                 /* Round length to the nearest 3-bit */
 573                                 rounded_len = (((len - 1) / 3) + 1) * 3;
 574                                 v.u &= ((uint64_t) 1 << rounded_len) - 1;
 575                         }
 576                 }
 577
 578                 g_string_append_printf(pretty->string, "0%" PRIo64, v.u);
 579                 break;
 580         }
 581         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL:
 582                 if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
 583                                 ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
 584                         g_string_append_printf(pretty->string, "%" PRIu64, v.u);
 585                 } else {
 586                         g_string_append_printf(pretty->string, "%" PRId64, v.s);
 587                 }
 588                 break;
 589         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL:
 590         {
 591                 int len;
 592
 593                 len = bt_field_class_integer_get_field_value_range(int_fc);
 594                 if (len < 64) {
 595                         /* Round length to the nearest nibble */
 596                         uint8_t rounded_len = ((len + 3) & ~0x3);
 597
 598                         v.u &= ((uint64_t) 1 << rounded_len) - 1;
 599                 }
 600
 601                 g_string_append_printf(pretty->string, "0x%" PRIX64, v.u);
 602                 break;
 603         }
 604         default:
 605                 ret = -1;
 606                 goto end;
 607         }
 608 end:
 609         if (rst_color) {
 610                 g_string_append(pretty->string, COLOR_RST);
 611         }
 612         return ret;
 613 }
 614
 615 static
 616 void print_escape_string(struct pretty_component *pretty, const char *str)
 617 {
 618         int i;
 619
 620         g_string_append_c(pretty->string, '"');
 621
 622         for (i = 0; i < strlen(str); i++) {
 623                 /* Escape sequences not recognized by iscntrl(). */
 624                 switch (str[i]) {
 625                 case '\\':
 626                         g_string_append(pretty->string, "\\\\");
 627                         continue;
 628                 case '\'':
 629                         g_string_append(pretty->string, "\\\'");
 630                         continue;
 631                 case '\"':
 632                         g_string_append(pretty->string, "\\\"");
 633                         continue;
 634                 case '\?':
 635                         g_string_append(pretty->string, "\\\?");
 636                         continue;
 637                 }
 638
 639                 /* Standard characters. */
 640                 if (!iscntrl(str[i])) {
 641                         g_string_append_c(pretty->string, str[i]);
 642                         continue;
 643                 }
 644
 645                 switch (str[i]) {
 646                 case '\0':
 647                         g_string_append(pretty->string, "\\0");
 648                         break;
 649                 case '\a':
 650                         g_string_append(pretty->string, "\\a");
 651                         break;
 652                 case '\b':
 653                         g_string_append(pretty->string, "\\b");
 654                         break;
 655                 case '\e':
 656                         g_string_append(pretty->string, "\\e");
 657                         break;
 658                 case '\f':
 659                         g_string_append(pretty->string, "\\f");
 660                         break;
 661                 case '\n':
 662                         g_string_append(pretty->string, "\\n");
 663                         break;
 664                 case '\r':
 665                         g_string_append(pretty->string, "\\r");
 666                         break;
 667                 case '\t':
 668                         g_string_append(pretty->string, "\\t");
 669                         break;
 670                 case '\v':
 671                         g_string_append(pretty->string, "\\v");
 672                         break;
 673                 default:
 674                         /* Unhandled control-sequence, print as hex. */
 675                         g_string_append_printf(pretty->string, "\\x%02x", str[i]);
 676                         break;
 677                 }
 678         }
 679
 680         g_string_append_c(pretty->string, '"');
 681 }
 682
 683 static
 684 int print_enum(struct pretty_component *pretty,
 685                 const bt_field *field)
 686 {
 687         int ret = 0;
 688         const bt_field_class *enumeration_field_class = NULL;
 689         bt_field_class_enumeration_mapping_label_array label_array;
 690         uint64_t label_count;
 691         uint64_t i;
 692
 693         enumeration_field_class = bt_field_borrow_class_const(field);
 694         if (!enumeration_field_class) {
 695                 ret = -1;
 696                 goto end;
 697         }
 698
 699         switch (bt_field_get_class_type(field)) {
 700         case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
 701                 ret = bt_field_unsigned_enumeration_get_mapping_labels(field,
 702                         &label_array, &label_count);
 703                 break;
 704         case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
 705                 ret = bt_field_signed_enumeration_get_mapping_labels(field,
 706                         &label_array, &label_count);
 707                 break;
 708         default:
 709                 abort();
 710         }
 711
 712         if (ret) {
 713                 ret = -1;
 714                 goto end;
 715         }
 716
 717         g_string_append(pretty->string, "( ");
 718         if (label_count == 0) {
 719                 if (pretty->use_colors) {
 720                         g_string_append(pretty->string, COLOR_UNKNOWN);
 721                 }
 722                 g_string_append(pretty->string, "<unknown>");
 723                 if (pretty->use_colors) {
 724                         g_string_append(pretty->string, COLOR_RST);
 725                 }
 726                 goto skip_loop;
 727         }
 728         for (i = 0; i < label_count; i++) {
 729                 const char *mapping_name = label_array[i];
 730
 731                 if (i != 0) {
 732                         g_string_append(pretty->string, ", ");
 733                 }
 734                 if (pretty->use_colors) {
 735                         g_string_append(pretty->string, COLOR_ENUM_MAPPING_NAME);
 736                 }
 737                 print_escape_string(pretty, mapping_name);
 738                 if (pretty->use_colors) {
 739                         g_string_append(pretty->string, COLOR_RST);
 740                 }
 741         }
 742 skip_loop:
 743         g_string_append(pretty->string, " : container = ");
 744         ret = print_integer(pretty, field);
 745         if (ret != 0) {
 746                 goto end;
 747         }
 748         g_string_append(pretty->string, " )");
 749 end:
 750         return ret;
 751 }
 752
 753 static
 754 int filter_field_name(struct pretty_component *pretty, const char *field_name,
 755                 GQuark *filter_fields, int filter_array_len)
 756 {
 757         int i;
 758         GQuark field_quark = g_quark_try_string(field_name);
 759
 760         if (!field_quark || pretty->options.verbose) {
 761                 return 1;
 762         }
 763
 764         for (i = 0; i < filter_array_len; i++) {
 765                 if (field_quark == filter_fields[i]) {
 766                         return 0;
 767                 }
 768         }
 769         return 1;
 770 }
 771
 772 static
 773 int print_struct_field(struct pretty_component *pretty,
 774                 const bt_field *_struct,
 775                 const bt_field_class *struct_class,
 776                 uint64_t i, bool print_names, uint64_t *nr_printed_fields,
 777                 GQuark *filter_fields, int filter_array_len)
 778 {
 779         int ret = 0;
 780         const char *field_name;
 781         const bt_field *field = NULL;
 782         const bt_field_class_structure_member *member;
 783
 784         field = bt_field_structure_borrow_member_field_by_index_const(_struct, i);
 785         if (!field) {
 786                 ret = -1;
 787                 goto end;
 788         }
 789
 790         member = bt_field_class_structure_borrow_member_by_index_const(
 791                 struct_class, i);
 792         field_name = bt_field_class_structure_member_get_name(member);
 793
 794         if (filter_fields && !filter_field_name(pretty, field_name,
 795                                 filter_fields, filter_array_len)) {
 796                 ret = 0;
 797                 goto end;
 798         }
 799
 800         if (*nr_printed_fields > 0) {
 801                 g_string_append(pretty->string, ", ");
 802         } else {
 803                 g_string_append(pretty->string, " ");
 804         }
 805         if (print_names) {
 806                 print_field_name_equal(pretty, field_name);
 807         }
 808         ret = print_field(pretty, field, print_names, NULL, 0);
 809         *nr_printed_fields += 1;
 810
 811 end:
 812         return ret;
 813 }
 814
 815 static
 816 int print_struct(struct pretty_component *pretty,
 817                 const bt_field *_struct, bool print_names,
 818                 GQuark *filter_fields, int filter_array_len)
 819 {
 820         int ret = 0;
 821         const bt_field_class *struct_class = NULL;
 822         uint64_t nr_fields, i, nr_printed_fields;
 823
 824         struct_class = bt_field_borrow_class_const(_struct);
 825         if (!struct_class) {
 826                 ret = -1;
 827                 goto end;
 828         }
 829
 830         nr_fields = bt_field_class_structure_get_member_count(struct_class);
 831
 832         g_string_append(pretty->string, "{");
 833         pretty->depth++;
 834         nr_printed_fields = 0;
 835         for (i = 0; i < nr_fields; i++) {
 836                 ret = print_struct_field(pretty, _struct, struct_class, i,
 837                                 print_names, &nr_printed_fields, filter_fields,
 838                                 filter_array_len);
 839                 if (ret != 0) {
 840                         goto end;
 841                 }
 842         }
 843         pretty->depth--;
 844         g_string_append(pretty->string, " }");
 845
 846 end:
 847         return ret;
 848 }
 849
 850 static
 851 int print_array_field(struct pretty_component *pretty,
 852                 const bt_field *array, uint64_t i, bool print_names)
 853 {
 854         const bt_field *field = NULL;
 855
 856         if (i != 0) {
 857                 g_string_append(pretty->string, ", ");
 858         } else {
 859                 g_string_append(pretty->string, " ");
 860         }
 861         if (print_names) {
 862                 g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
 863         }
 864
 865         field = bt_field_array_borrow_element_field_by_index_const(array, i);
 866         BT_ASSERT(field);
 867         return print_field(pretty, field, print_names, NULL, 0);
 868 }
 869
 870 static
 871 int print_array(struct pretty_component *pretty,
 872                 const bt_field *array, bool print_names)
 873 {
 874         int ret = 0;
 875         const bt_field_class *array_class = NULL;
 876         uint64_t len;
 877         uint64_t i;
 878
 879         array_class = bt_field_borrow_class_const(array);
 880         if (!array_class) {
 881                 ret = -1;
 882                 goto end;
 883         }
 884         len = bt_field_array_get_length(array);
 885         g_string_append(pretty->string, "[");
 886         pretty->depth++;
 887         for (i = 0; i < len; i++) {
 888                 ret = print_array_field(pretty, array, i, print_names);
 889                 if (ret != 0) {
 890                         goto end;
 891                 }
 892         }
 893         pretty->depth--;
 894         g_string_append(pretty->string, " ]");
 895
 896 end:
 897         return ret;
 898 }
 899
 900 static
 901 int print_sequence_field(struct pretty_component *pretty,
 902                 const bt_field *seq, uint64_t i, bool print_names)
 903 {
 904         const bt_field *field = NULL;
 905
 906         if (i != 0) {
 907                 g_string_append(pretty->string, ", ");
 908         } else {
 909                 g_string_append(pretty->string, " ");
 910         }
 911         if (print_names) {
 912                 g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
 913         }
 914
 915         field = bt_field_array_borrow_element_field_by_index_const(seq, i);
 916         BT_ASSERT(field);
 917         return print_field(pretty, field, print_names, NULL, 0);
 918 }
 919
 920 static
 921 int print_sequence(struct pretty_component *pretty,
 922                 const bt_field *seq, bool print_names)
 923 {
 924         int ret = 0;
 925         uint64_t len;
 926         uint64_t i;
 927
 928         len = bt_field_array_get_length(seq);
 929         g_string_append(pretty->string, "[");
 930
 931         pretty->depth++;
 932         for (i = 0; i < len; i++) {
 933                 ret = print_sequence_field(pretty, seq, i, print_names);
 934                 if (ret != 0) {
 935                         goto end;
 936                 }
 937         }
 938         pretty->depth--;
 939         g_string_append(pretty->string, " ]");
 940
 941 end:
 942         return ret;
 943 }
 944
 945 static
 946 int print_variant(struct pretty_component *pretty,
 947                 const bt_field *variant, bool print_names)
 948 {
 949         int ret = 0;
 950         const bt_field *field = NULL;
 951
 952         field = bt_field_variant_borrow_selected_option_field_const(variant);
 953         BT_ASSERT(field);
 954         g_string_append(pretty->string, "{ ");
 955         pretty->depth++;
 956         if (print_names) {
 957                 // TODO: find tag's name using field path
 958                 // print_field_name_equal(pretty, tag_choice);
 959         }
 960         ret = print_field(pretty, field, print_names, NULL, 0);
 961         if (ret != 0) {
 962                 goto end;
 963         }
 964         pretty->depth--;
 965         g_string_append(pretty->string, " }");
 966
 967 end:
 968         return ret;
 969 }
 970
 971 static
 972 int print_field(struct pretty_component *pretty,
 973                 const bt_field *field, bool print_names,
 974                 GQuark *filter_fields, int filter_array_len)
 975 {
 976         bt_field_class_type class_id;
 977
 978         class_id = bt_field_get_class_type(field);
 979         switch (class_id) {
 980         case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
 981         case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
 982                 return print_integer(pretty, field);
 983         case BT_FIELD_CLASS_TYPE_REAL:
 984         {
 985                 double v;
 986
 987                 v = bt_field_real_get_value(field);
 988                 if (pretty->use_colors) {
 989                         g_string_append(pretty->string, COLOR_NUMBER_VALUE);
 990                 }
 991                 g_string_append_printf(pretty->string, "%g", v);
 992                 if (pretty->use_colors) {
 993                         g_string_append(pretty->string, COLOR_RST);
 994                 }
 995                 return 0;
 996         }
 997         case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
 998         case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
 999                 return print_enum(pretty, field);
1000         case BT_FIELD_CLASS_TYPE_STRING:
1001         {
1002                 const char *str;
1003
1004                 str = bt_field_string_get_value(field);
1005                 if (!str) {
1006                         return -1;
1007                 }
1008
1009                 if (pretty->use_colors) {
1010                         g_string_append(pretty->string, COLOR_STRING_VALUE);
1011                 }
1012                 print_escape_string(pretty, str);
1013                 if (pretty->use_colors) {
1014                         g_string_append(pretty->string, COLOR_RST);
1015                 }
1016                 return 0;
1017         }
1018         case BT_FIELD_CLASS_TYPE_STRUCTURE:
1019                 return print_struct(pretty, field, print_names, filter_fields,
1020                                 filter_array_len);
1021         case BT_FIELD_CLASS_TYPE_VARIANT:
1022                 return print_variant(pretty, field, print_names);
1023         case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
1024                 return print_array(pretty, field, print_names);
1025         case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
1026                 return print_sequence(pretty, field, print_names);
1027         default:
1028                 // TODO: log instead
1029                 fprintf(pretty->err, "[error] Unknown type id: %d\n", (int) class_id);
1030                 return -1;
1031         }
1032 }
1033
1034 static
1035 int print_stream_packet_context(struct pretty_component *pretty,
1036                 const bt_event *event)
1037 {
1038         int ret = 0;
1039         const bt_packet *packet = NULL;
1040         const bt_field *main_field = NULL;
1041
1042         packet = bt_event_borrow_packet_const(event);
1043         if (!packet) {
1044                 ret = -1;
1045                 goto end;
1046         }
1047         main_field = bt_packet_borrow_context_field_const(packet);
1048         if (!main_field) {
1049                 goto end;
1050         }
1051         if (!pretty->start_line) {
1052                 g_string_append(pretty->string, ", ");
1053         }
1054         pretty->start_line = false;
1055         if (pretty->options.print_scope_field_names) {
1056                 print_name_equal(pretty, "stream.packet.context");
1057         }
1058         ret = print_field(pretty, main_field,
1059                         pretty->options.print_context_field_names,
1060                         stream_packet_context_quarks,
1061                         STREAM_PACKET_CONTEXT_QUARKS_LEN);
1062
1063 end:
1064         return ret;
1065 }
1066
1067 static
1068 int print_stream_event_context(struct pretty_component *pretty,
1069                 const bt_event *event)
1070 {
1071         int ret = 0;
1072         const bt_field *main_field = NULL;
1073
1074         main_field = bt_event_borrow_common_context_field_const(event);
1075         if (!main_field) {
1076                 goto end;
1077         }
1078         if (!pretty->start_line) {
1079                 g_string_append(pretty->string, ", ");
1080         }
1081         pretty->start_line = false;
1082         if (pretty->options.print_scope_field_names) {
1083                 print_name_equal(pretty, "stream.event.context");
1084         }
1085         ret = print_field(pretty, main_field,
1086                         pretty->options.print_context_field_names, NULL, 0);
1087
1088 end:
1089         return ret;
1090 }
1091
1092 static
1093 int print_event_context(struct pretty_component *pretty,
1094                 const bt_event *event)
1095 {
1096         int ret = 0;
1097         const bt_field *main_field = NULL;
1098
1099         main_field = bt_event_borrow_specific_context_field_const(event);
1100         if (!main_field) {
1101                 goto end;
1102         }
1103         if (!pretty->start_line) {
1104                 g_string_append(pretty->string, ", ");
1105         }
1106         pretty->start_line = false;
1107         if (pretty->options.print_scope_field_names) {
1108                 print_name_equal(pretty, "event.context");
1109         }
1110         ret = print_field(pretty, main_field,
1111                         pretty->options.print_context_field_names, NULL, 0);
1112
1113 end:
1114         return ret;
1115 }
1116
1117 static
1118 int print_event_payload(struct pretty_component *pretty,
1119                 const bt_event *event)
1120 {
1121         int ret = 0;
1122         const bt_field *main_field = NULL;
1123
1124         main_field = bt_event_borrow_payload_field_const(event);
1125         if (!main_field) {
1126                 goto end;
1127         }
1128         if (!pretty->start_line) {
1129                 g_string_append(pretty->string, ", ");
1130         }
1131         pretty->start_line = false;
1132         if (pretty->options.print_scope_field_names) {
1133                 print_name_equal(pretty, "event.fields");
1134         }
1135         ret = print_field(pretty, main_field,
1136                         pretty->options.print_payload_field_names, NULL, 0);
1137
1138 end:
1139         return ret;
1140 }
1141
1142 static
1143 int flush_buf(FILE *stream, struct pretty_component *pretty)
1144 {
1145         int ret = 0;
1146
1147         if (pretty->string->len == 0) {
1148                 goto end;
1149         }
1150
1151         if (fwrite(pretty->string->str, pretty->string->len, 1, stream) != 1) {
1152                 ret = -1;
1153         }
1154
1155 end:
1156         return ret;
1157 }
1158
1159 BT_HIDDEN
1160 int pretty_print_event(struct pretty_component *pretty,
1161                 const bt_message *event_msg)
1162 {
1163         int ret;
1164         const bt_event *event =
1165                 bt_message_event_borrow_event_const(event_msg);
1166
1167         BT_ASSERT(event);
1168         pretty->start_line = true;
1169         g_string_assign(pretty->string, "");
1170         ret = print_event_header(pretty, event_msg);
1171         if (ret != 0) {
1172                 goto end;
1173         }
1174
1175         ret = print_stream_packet_context(pretty, event);
1176         if (ret != 0) {
1177                 goto end;
1178         }
1179
1180         ret = print_stream_event_context(pretty, event);
1181         if (ret != 0) {
1182                 goto end;
1183         }
1184
1185         ret = print_event_context(pretty, event);
1186         if (ret != 0) {
1187                 goto end;
1188         }
1189
1190         ret = print_event_payload(pretty, event);
1191         if (ret != 0) {
1192                 goto end;
1193         }
1194
1195         g_string_append_c(pretty->string, '\n');
1196         if (flush_buf(pretty->out, pretty)) {
1197                 ret = -1;
1198                 goto end;
1199         }
1200
1201 end:
1202         return ret;
1203 }
1204
1205 static
1206 int print_discarded_elements_msg(struct pretty_component *pretty,
1207                 const bt_stream *stream,
1208                 const bt_clock_snapshot *begin_clock_snapshot,
1209                 const bt_clock_snapshot *end_clock_snapshot,
1210                 uint64_t count, const char *elem_type)
1211 {
1212         int ret = 0;
1213         const bt_stream_class *stream_class = NULL;
1214         const bt_trace *trace = NULL;
1215         const char *stream_name;
1216         const char *trace_name;
1217         bt_uuid trace_uuid;
1218         int64_t stream_class_id;
1219         int64_t stream_id;
1220         const char *init_msg;
1221
1222         /* Stream name */
1223         stream_name = bt_stream_get_name(stream);
1224         if (!stream_name) {
1225                 stream_name = "(unknown)";
1226         }
1227
1228         /* Stream class ID */
1229         stream_class = bt_stream_borrow_class_const(stream);
1230         BT_ASSERT(stream_class);
1231         stream_class_id = bt_stream_class_get_id(stream_class);
1232
1233         /* Stream ID */
1234         stream_id = bt_stream_get_id(stream);
1235
1236         /* Trace name */
1237         trace = bt_stream_borrow_trace_const(stream);
1238         BT_ASSERT(trace);
1239         trace_name = bt_trace_get_name(trace);
1240         if (!trace_name) {
1241                 trace_name = "(unknown)";
1242         }
1243
1244         /* Trace UUID */
1245         trace_uuid = bt_trace_class_get_uuid(
1246                 bt_trace_borrow_class_const(trace));
1247
1248         /* Format message */
1249         g_string_assign(pretty->string, "");
1250
1251         if (count == UINT64_C(-1)) {
1252                 init_msg = "Tracer may have discarded";
1253         } else {
1254                 init_msg = "Tracer discarded";
1255         }
1256
1257         g_string_append_printf(pretty->string,
1258                 "%s%sWARNING%s%s: %s ",
1259                 bt_common_color_fg_yellow(),
1260                 bt_common_color_bold(),
1261                 bt_common_color_reset(),
1262                 bt_common_color_fg_yellow(), init_msg);
1263
1264         if (count == UINT64_C(-1)) {
1265                 g_string_append_printf(pretty->string, "%ss", elem_type);
1266         } else {
1267                 g_string_append_printf(pretty->string,
1268                         "%" PRIu64 " %s%s", count, elem_type,
1269                         count == 1 ? "" : "s");
1270         }
1271
1272         g_string_append_c(pretty->string, ' ');
1273
1274         if (begin_clock_snapshot && end_clock_snapshot) {
1275                 g_string_append(pretty->string, "between [");
1276                 print_timestamp_wall(pretty, begin_clock_snapshot, false);
1277                 g_string_append(pretty->string, "] and [");
1278                 print_timestamp_wall(pretty, end_clock_snapshot, false);
1279                 g_string_append(pretty->string, "]");
1280         } else {
1281                 g_string_append(pretty->string, "(unknown time range)");
1282         }
1283
1284         g_string_append_printf(pretty->string, " in trace \"%s\" ", trace_name);
1285
1286         if (trace_uuid) {
1287                 g_string_append_printf(pretty->string,
1288                         "(UUID: %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x) ",
1289                         trace_uuid[0],
1290                         trace_uuid[1],
1291                         trace_uuid[2],
1292                         trace_uuid[3],
1293                         trace_uuid[4],
1294                         trace_uuid[5],
1295                         trace_uuid[6],
1296                         trace_uuid[7],
1297                         trace_uuid[8],
1298                         trace_uuid[9],
1299                         trace_uuid[10],
1300                         trace_uuid[11],
1301                         trace_uuid[12],
1302                         trace_uuid[13],
1303                         trace_uuid[14],
1304                         trace_uuid[15]);
1305         } else {
1306                 g_string_append(pretty->string, "(no UUID) ");
1307         }
1308
1309         g_string_append_printf(pretty->string,
1310                 "within stream \"%s\" (stream class ID: %" PRIu64 ", ",
1311                 stream_name, stream_class_id);
1312
1313         if (stream_id >= 0) {
1314                 g_string_append_printf(pretty->string,
1315                         "stream ID: %" PRIu64, stream_id);
1316         } else {
1317                 g_string_append(pretty->string, "no stream ID");
1318         }
1319
1320         g_string_append_printf(pretty->string, ").%s\n",
1321                 bt_common_color_reset());
1322
1323         /*
1324          * Print to standard error stream to remain backward compatible
1325          * with Babeltrace 1.
1326          */
1327         if (flush_buf(stderr, pretty)) {
1328                 ret = -1;
1329         }
1330
1331         return ret;
1332 }
1333
1334 BT_HIDDEN
1335 int pretty_print_discarded_items(struct pretty_component *pretty,
1336                 const bt_message *msg)
1337 {
1338         const bt_clock_snapshot *begin = NULL;
1339         const bt_clock_snapshot *end = NULL;
1340         const bt_stream *stream;
1341         const bt_stream_class *stream_class;
1342         uint64_t count = UINT64_C(-1);
1343         const char *elem_type;
1344
1345         switch (bt_message_get_type(msg)) {
1346         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
1347                 stream = bt_message_discarded_events_borrow_stream_const(msg);
1348
1349                 if (bt_message_discarded_events_get_count(msg, &count) ==
1350                                 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1351                         count = UINT64_C(-1);
1352                 }
1353
1354                 elem_type = "event";
1355                 break;
1356         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
1357                 stream = bt_message_discarded_packets_borrow_stream_const(msg);
1358
1359                 if (bt_message_discarded_packets_get_count(msg, &count) ==
1360                                 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
1361                         count = UINT64_C(-1);
1362                 }
1363
1364                 elem_type = "packet";
1365                 break;
1366         default:
1367                 abort();
1368         }
1369
1370         BT_ASSERT(stream);
1371         stream_class = bt_stream_borrow_class_const(stream);
1372
1373         switch (bt_message_get_type(msg)) {
1374         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
1375                 if (bt_stream_class_discarded_events_have_default_clock_snapshots(
1376                                 stream_class)) {
1377                         begin = bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
1378                                 msg);
1379                         end = bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
1380                                 msg);
1381                 }
1382
1383                 break;
1384         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
1385                 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(
1386                                 stream_class)) {
1387                         begin = bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
1388                                 msg);
1389                         end = bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
1390                                 msg);
1391                 }
1392
1393                 break;
1394         default:
1395                 abort();
1396         }
1397
1398         print_discarded_elements_msg(pretty, stream, begin, end,
1399                 count, elem_type);
1400         return 0;
1401 }