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