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