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