gdb/ui-out.h

   1 /* Output generating routines for GDB.
   2
   3    Copyright (C) 1999-2024 Free Software Foundation, Inc.
   4
   5    Contributed by Cygnus Solutions.
   6    Written by Fernando Nasser for Cygnus.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #ifndef GDB_UI_OUT_H
  24 #define GDB_UI_OUT_H
  25
  26 #include <vector>
  27
  28 #include "gdbsupport/enum-flags.h"
  29 #include "ui-style.h"
  30
  31 class ui_out_level;
  32 class ui_out_table;
  33 struct ui_file;
  34
  35 /* the current ui_out */
  36
  37 /* FIXME: This should not be a global but something passed down from main.c
  38    or top.c.  */
  39 extern struct ui_out **current_ui_current_uiout_ptr (void);
  40 #define current_uiout (*current_ui_current_uiout_ptr ())
  41
  42 /* alignment enum */
  43 enum ui_align
  44   {
  45     ui_left = -1,
  46     ui_center,
  47     ui_right,
  48     ui_noalign
  49   };
  50
  51 /* flags enum */
  52 enum ui_out_flag
  53 {
  54   ui_source_list = (1 << 0),
  55   fix_multi_location_breakpoint_output = (1 << 1),
  56   /* This indicates that %pF should be disallowed in a printf format
  57      string.  */
  58   disallow_ui_out_field = (1 << 2),
  59   fix_breakpoint_script_output = (1 << 3),
  60 };
  61
  62 DEF_ENUM_FLAGS_TYPE (ui_out_flag, ui_out_flags);
  63
  64 /* Prototypes for ui-out API.  */
  65
  66 /* A result is a recursive data structure consisting of lists and
  67    tuples.  */
  68
  69 enum ui_out_type
  70   {
  71     ui_out_type_tuple,
  72     ui_out_type_list
  73   };
  74
  75 /* The possible kinds of fields.  */
  76 enum class field_kind
  77   {
  78     /* "FIELD_STRING" needs a funny name to avoid clashes with tokens
  79        named "STRING".  See PR build/25250.  FIELD_SIGNED is given a
  80        similar name for consistency.  */
  81     FIELD_SIGNED,
  82     FIELD_STRING,
  83   };
  84
  85 /* The base type of all fields that can be emitted using %pF.  */
  86
  87 struct base_field_s
  88 {
  89   const char *name;
  90   field_kind kind;
  91 };
  92
  93 /* A signed integer field, to be passed to %pF in format strings.  */
  94
  95 struct signed_field_s : base_field_s
  96 {
  97   LONGEST val;
  98 };
  99
 100 /* Construct a temporary signed_field_s on the caller's stack and
 101    return a pointer to the constructed object.  We use this because
 102    it's not possible to pass a reference via va_args.  */
 103
 104 static inline signed_field_s *
 105 signed_field (const char *name, LONGEST val,
 106               signed_field_s &&tmp = {})
 107 {
 108   tmp.name = name;
 109   tmp.kind = field_kind::FIELD_SIGNED;
 110   tmp.val = val;
 111   return &tmp;
 112 }
 113
 114 /* A string field, to be passed to %pF in format strings.  */
 115
 116 struct string_field_s : base_field_s
 117 {
 118   const char *str;
 119 };
 120
 121 /* Construct a temporary string_field_s on the caller's stack and
 122    return a pointer to the constructed object.  We use this because
 123    it's not possible to pass a reference via va_args.  */
 124
 125 static inline string_field_s *
 126 string_field (const char *name, const char *str,
 127               string_field_s &&tmp = {})
 128 {
 129   tmp.name = name;
 130   tmp.kind = field_kind::FIELD_STRING;
 131   tmp.str = str;
 132   return &tmp;
 133 }
 134
 135 /* A styled string.  */
 136
 137 struct styled_string_s
 138 {
 139   /* The style.  */
 140   ui_file_style style;
 141
 142   /* The string.  */
 143   const char *str;
 144 };
 145
 146 /* Construct a temporary styled_string_s on the caller's stack and
 147    return a pointer to the constructed object.  We use this because
 148    it's not possible to pass a reference via va_args.  */
 149
 150 static inline styled_string_s *
 151 styled_string (const ui_file_style &style, const char *str,
 152                styled_string_s &&tmp = {})
 153 {
 154   tmp.style = style;
 155   tmp.str = str;
 156   return &tmp;
 157 }
 158
 159 class ui_out
 160 {
 161  public:
 162
 163   explicit ui_out (ui_out_flags flags = 0);
 164   virtual ~ui_out ();
 165
 166   DISABLE_COPY_AND_ASSIGN (ui_out);
 167
 168   void push_level (ui_out_type type);
 169   void pop_level (ui_out_type type);
 170
 171   /* A table can be considered a special tuple/list combination with the
 172      implied structure: ``table = { hdr = { header, ... } , body = [ {
 173      field, ... }, ... ] }''.  If NR_ROWS is negative then there is at
 174      least one row.  */
 175
 176   void table_begin (int nr_cols, int nr_rows, const std::string &tblid);
 177   void table_header (int width, ui_align align, const std::string &col_name,
 178                      const std::string &col_hdr);
 179   void table_body ();
 180   void table_end ();
 181
 182   void begin (ui_out_type type, const char *id);
 183   void end (ui_out_type type);
 184
 185   void field_signed (const char *fldname, LONGEST value,
 186                      const ui_file_style &style = ui_file_style ());
 187   void field_fmt_signed (int width, ui_align align, const char *fldname,
 188                          LONGEST value);
 189   /* Like field_signed, but print an unsigned value.  */
 190   void field_unsigned (const char *fldname, ULONGEST value);
 191   void field_core_addr (const char *fldname, struct gdbarch *gdbarch,
 192                         CORE_ADDR address);
 193   void field_string (const char *fldname, const char *string,
 194                      const ui_file_style &style = ui_file_style ());
 195   void field_string (const char *fldname, const std::string &string,
 196                      const ui_file_style &style = ui_file_style ())
 197   {
 198     field_string (fldname, string.c_str (), style);
 199   }
 200   void field_stream (const char *fldname, string_file &stream,
 201                      const ui_file_style &style = ui_file_style ());
 202   void field_skip (const char *fldname);
 203   void field_fmt (const char *fldname, const char *format, ...)
 204     ATTRIBUTE_PRINTF (3, 4);
 205   void field_fmt (const char *fldname, const ui_file_style &style,
 206                   const char *format, ...)
 207     ATTRIBUTE_PRINTF (4, 5);
 208
 209   void spaces (int numspaces) { do_spaces (numspaces); }
 210   void text (const char *string) { do_text (string); }
 211   void text (const std::string &string) { text (string.c_str ()); }
 212
 213   /* Output a printf-style formatted string.  In addition to the usual
 214      printf format specs, this supports a few GDB-specific
 215      formatters:
 216
 217      - '%pF' - output a field.
 218
 219        The argument is a field, wrapped in any of the base_field_s
 220        subclasses.  signed_field for integer fields, string_field for
 221        string fields.  This is preferred over separate
 222        uiout->field_signed(), uiout_>field_string() etc. calls when
 223        the formatted message is translatable.  E.g.:
 224
 225          uiout->message (_("\nWatchpoint %pF deleted because the program has "
 226                          "left the block in\n"
 227                          "which its expression is valid.\n"),
 228                          signed_field ("wpnum", b->number));
 229
 230      - '%p[' - output the following text in a specified style.
 231        '%p]' - output the following text in the default style.
 232
 233        The argument to '%p[' is a ui_file_style pointer.  The argument
 234        to '%p]' must be nullptr.
 235
 236        This is useful when you want to output some portion of a string
 237        literal in some style.  E.g.:
 238
 239          uiout->message (_(" %p[<repeats %u times>%p]"),
 240                          metadata_style.style ().ptr (),
 241                          reps, repeats, nullptr);
 242
 243      - '%ps' - output a styled string.
 244
 245        The argument is the result of a call to styled_string.  This is
 246        useful when you want to output some runtime-generated string in
 247        some style.  E.g.:
 248
 249          uiout->message (_("this is a target address %ps.\n"),
 250                          styled_string (address_style.style (),
 251                                         paddress (gdbarch, pc)));
 252
 253      Note that these all "abuse" the %p printf format spec, in order
 254      to be compatible with GCC's printf format checking.  This is OK
 255      because code in GDB that wants to print a host address should use
 256      host_address_to_string instead of %p.  */
 257   void message (const char *format, ...) ATTRIBUTE_PRINTF (2, 3);
 258   void vmessage (const ui_file_style &in_style,
 259                  const char *format, va_list args) ATTRIBUTE_PRINTF (3, 0);
 260
 261   void wrap_hint (int indent) { do_wrap_hint (indent); }
 262
 263   void flush () { do_flush (); }
 264
 265   /* Redirect the output of a ui_out object temporarily.  */
 266   void redirect (ui_file *outstream) { do_redirect (outstream); }
 267
 268   ui_out_flags test_flags (ui_out_flags mask)
 269   { return m_flags & mask; }
 270
 271   /* HACK: Code in GDB is currently checking to see the type of ui_out
 272      builder when determining which output to produce.  This function is
 273      a hack to encapsulate that test.  Once GDB manages to separate the
 274      CLI/MI from the core of GDB the problem should just go away ....  */
 275
 276   bool is_mi_like_p () const { return do_is_mi_like_p (); }
 277
 278   bool query_table_field (int colno, int *width, int *alignment,
 279                           const char **col_name);
 280
 281   /* Return true if this stream is prepared to handle style
 282      escapes.  */
 283   virtual bool can_emit_style_escape () const = 0;
 284
 285   /* Return the ui_file currently used for output.  */
 286   virtual ui_file *current_stream () const = 0;
 287
 288   /* An object that starts and finishes displaying progress updates.  */
 289   class progress_update
 290   {
 291   public:
 292     /* Represents the printing state of a progress update.  */
 293     enum state
 294     {
 295       /* Printing will start with the next update.  */
 296       START,
 297       /* Printing has already started.  */
 298       WORKING,
 299       /* Progress bar printing has already started.  */
 300       BAR
 301     };
 302
 303     /* SHOULD_PRINT indicates whether something should be printed for a tty.  */
 304     progress_update ()
 305     {
 306       m_uiout = current_uiout;
 307       m_uiout->do_progress_start ();
 308     }
 309
 310     ~progress_update ()
 311     {
 312       m_uiout->do_progress_end ();
 313     }
 314
 315     progress_update (const progress_update &) = delete;
 316     progress_update &operator= (const progress_update &) = delete;
 317
 318     /* Emit some progress for this progress meter.  Includes current
 319        amount of progress made and total amount in the display.  */
 320     void update_progress (const std::string& msg, const char *unit,
 321                           double cur, double total)
 322     {
 323       m_uiout->do_progress_notify (msg, unit, cur, total);
 324     }
 325
 326     /* Emit some progress for this progress meter.  */
 327     void update_progress (const std::string& msg)
 328     {
 329       m_uiout->do_progress_notify (msg, "", -1, -1);
 330     }
 331
 332   private:
 333
 334     struct ui_out *m_uiout;
 335   };
 336
 337 protected:
 338
 339   virtual void do_table_begin (int nbrofcols, int nr_rows, const char *tblid)
 340     = 0;
 341   virtual void do_table_body () = 0;
 342   virtual void do_table_end () = 0;
 343   virtual void do_table_header (int width, ui_align align,
 344                                 const std::string &col_name,
 345                                 const std::string &col_hdr) = 0;
 346
 347   virtual void do_begin (ui_out_type type, const char *id) = 0;
 348   virtual void do_end (ui_out_type type) = 0;
 349   virtual void do_field_signed (int fldno, int width, ui_align align,
 350                                 const char *fldname, LONGEST value,
 351                                 const ui_file_style &style) = 0;
 352   virtual void do_field_unsigned (int fldno, int width, ui_align align,
 353                                   const char *fldname, ULONGEST value) = 0;
 354   virtual void do_field_skip (int fldno, int width, ui_align align,
 355                               const char *fldname) = 0;
 356   virtual void do_field_string (int fldno, int width, ui_align align,
 357                                 const char *fldname, const char *string,
 358                                 const ui_file_style &style) = 0;
 359   virtual void do_field_fmt (int fldno, int width, ui_align align,
 360                              const char *fldname, const ui_file_style &style,
 361                              const char *format, va_list args)
 362     ATTRIBUTE_PRINTF (7, 0) = 0;
 363   virtual void do_spaces (int numspaces) = 0;
 364   virtual void do_text (const char *string) = 0;
 365   virtual void do_message (const ui_file_style &style,
 366                            const char *format, va_list args)
 367     ATTRIBUTE_PRINTF (3,0) = 0;
 368   virtual void do_wrap_hint (int indent) = 0;
 369   virtual void do_flush () = 0;
 370   virtual void do_redirect (struct ui_file *outstream) = 0;
 371
 372   virtual void do_progress_start () = 0;
 373   virtual void do_progress_notify (const std::string &, const char *,
 374                                    double, double) = 0;
 375   virtual void do_progress_end () = 0;
 376
 377   /* Set as not MI-like by default.  It is overridden in subclasses if
 378      necessary.  */
 379
 380   virtual bool do_is_mi_like_p () const
 381   { return false; }
 382
 383  private:
 384   void call_do_message (const ui_file_style &style, const char *format,
 385                         ...);
 386
 387   ui_out_flags m_flags;
 388
 389   /* Vector to store and track the ui-out levels.  */
 390   std::vector<std::unique_ptr<ui_out_level>> m_levels;
 391
 392   /* A table, if any.  At present only a single table is supported.  */
 393   std::unique_ptr<ui_out_table> m_table_up;
 394
 395   void verify_field (int *fldno, int *width, ui_align *align);
 396
 397   int level () const;
 398   ui_out_level *current_level () const;
 399 };
 400
 401 /* Start a new tuple or list on construction, and end it on
 402    destruction.  Normally this is used via the typedefs
 403    ui_out_emit_tuple and ui_out_emit_list.  */
 404 template<ui_out_type Type>
 405 class ui_out_emit_type
 406 {
 407 public:
 408
 409   ui_out_emit_type (struct ui_out *uiout, const char *id)
 410     : m_uiout (uiout)
 411   {
 412     uiout->begin (Type, id);
 413   }
 414
 415   ~ui_out_emit_type ()
 416   {
 417     m_uiout->end (Type);
 418   }
 419
 420   DISABLE_COPY_AND_ASSIGN (ui_out_emit_type);
 421
 422 private:
 423
 424   struct ui_out *m_uiout;
 425 };
 426
 427 typedef ui_out_emit_type<ui_out_type_tuple> ui_out_emit_tuple;
 428 typedef ui_out_emit_type<ui_out_type_list> ui_out_emit_list;
 429
 430 /* Start a new table on construction, and end the table on
 431    destruction.  */
 432 class ui_out_emit_table
 433 {
 434 public:
 435
 436   ui_out_emit_table (struct ui_out *uiout, int nr_cols, int nr_rows,
 437                      const char *tblid)
 438     : m_uiout (uiout)
 439   {
 440     m_uiout->table_begin (nr_cols, nr_rows, tblid);
 441   }
 442
 443   ~ui_out_emit_table ()
 444   {
 445     m_uiout->table_end ();
 446   }
 447
 448   ui_out_emit_table (const ui_out_emit_table &) = delete;
 449   ui_out_emit_table &operator= (const ui_out_emit_table &) = delete;
 450
 451 private:
 452
 453   struct ui_out *m_uiout;
 454 };
 455
 456 /* On construction, redirect a uiout to a given stream.  On
 457    destruction, pop the last redirection by calling the uiout's
 458    redirect method with a NULL parameter.  */
 459 class ui_out_redirect_pop
 460 {
 461 public:
 462
 463   ui_out_redirect_pop (ui_out *uiout, ui_file *stream)
 464     : m_uiout (uiout)
 465   {
 466     m_uiout->redirect (stream);
 467   }
 468
 469   ~ui_out_redirect_pop ()
 470   {
 471     m_uiout->redirect (NULL);
 472   }
 473
 474   ui_out_redirect_pop (const ui_out_redirect_pop &) = delete;
 475   ui_out_redirect_pop &operator= (const ui_out_redirect_pop &) = delete;
 476
 477 private:
 478   struct ui_out *m_uiout;
 479 };
 480
 481 struct buffered_streams;
 482
 483 /* Organizes writes to a collection of buffered output streams
 484    so that when flushed, output is written to all streams in
 485    chronological order.  */
 486
 487 struct buffer_group
 488 {
 489   buffer_group (ui_out *uiout);
 490
 491   /* Flush all buffered writes to the underlying output streams.  */
 492   void flush () const;
 493
 494   /* Record contents of BUF and associate it with STREAM.  */
 495   void write (const char *buf, long length_buf, ui_file *stream);
 496
 497   /* Record a wrap_here and associate it with STREAM.  */
 498   void wrap_here (int indent, ui_file *stream);
 499
 500   /* Record a call to flush and associate it with STREAM.  */
 501   void flush_here (ui_file *stream);
 502
 503 private:
 504
 505   struct output_unit
 506   {
 507     output_unit (std::string msg, int wrap_hint = -1, bool flush = false)
 508       : m_msg (msg), m_wrap_hint (wrap_hint), m_flush (flush)
 509     {}
 510
 511     /* Write contents of this output_unit to the underlying stream.  */
 512     void flush () const;
 513
 514     /* Underlying stream for which this output unit will be written to.  */
 515     ui_file *m_stream;
 516
 517     /* String to be written to underlying buffer.  */
 518     std::string m_msg;
 519
 520     /* Argument to wrap_here.  -1 indicates no wrap.  Used to call wrap_here
 521        during buffer flush.  */
 522     int m_wrap_hint;
 523
 524     /* Indicate that the underlying output stream's flush should be called.  */
 525     bool m_flush;
 526   };
 527
 528   /* Output_units to be written to buffered output streams.  */
 529   std::vector<output_unit> m_buffered_output;
 530
 531   /* Buffered output streams.  */
 532   std::unique_ptr<buffered_streams> m_buffered_streams;
 533 };
 534
 535 /* If FILE is a buffering_file, return it's underlying stream.  */
 536
 537 extern ui_file *get_unbuffered (ui_file *file);
 538
 539 /* Buffer output to gdb_stdout and gdb_stderr for the duration of FUNC.  */
 540
 541 template<typename F, typename... Arg>
 542 void
 543 do_with_buffered_output (F func, ui_out *uiout, Arg... args)
 544 {
 545   buffer_group g (uiout);
 546
 547   try
 548     {
 549       func (uiout, std::forward<Arg> (args)...);
 550     }
 551   catch (gdb_exception &ex)
 552     {
 553       /* Ideally flush would be called in the destructor of buffer_group,
 554          however flushing might cause an exception to be thrown.  Catch it
 555          and ensure the first exception propagates.  */
 556       try
 557         {
 558           g.flush ();
 559         }
 560       catch (const gdb_exception &)
 561         {
 562         }
 563
 564       throw_exception (std::move (ex));
 565     }
 566
 567   /* Try was successful.  Let any further exceptions propagate.  */
 568   g.flush ();
 569 }
 570
 571 /* Accumulate writes to an underlying ui_file.  Output to the
 572    underlying file is deferred until required.  */
 573
 574 struct buffering_file : public ui_file
 575 {
 576   buffering_file (buffer_group *group, ui_file *stream)
 577     : m_group (group),
 578       m_stream (stream)
 579   { /* Nothing.  */ }
 580
 581   /* Return the underlying output stream.  */
 582   ui_file *stream () const
 583   {
 584     return m_stream;
 585   }
 586
 587   /* Record the contents of BUF.  */
 588   void write (const char *buf, long length_buf) override
 589   {
 590     m_group->write (buf, length_buf, m_stream);
 591   }
 592
 593   /* Record a wrap_here call with argument INDENT.  */
 594   void wrap_here (int indent) override
 595   {
 596     m_group->wrap_here (indent, m_stream);
 597   }
 598
 599   /* Return true if the underlying stream is a tty.  */
 600   bool isatty () override
 601   {
 602     return m_stream->isatty ();
 603   }
 604
 605   /* Return true if ANSI escapes can be used on the underlying stream.  */
 606   bool can_emit_style_escape () override
 607   {
 608     return m_stream->can_emit_style_escape ();
 609   }
 610
 611   /* Flush the underlying output stream.  */
 612   void flush () override
 613   {
 614     return m_group->flush_here (m_stream);
 615   }
 616
 617 private:
 618
 619   /* Coordinates buffering across multiple buffering_files.  */
 620   buffer_group *m_group;
 621
 622   /* The underlying output stream.  */
 623   ui_file *m_stream;
 624 };
 625
 626 /* Attaches and detaches buffers for each of the gdb_std* streams.  */
 627
 628 struct buffered_streams
 629 {
 630   buffered_streams (buffer_group *group, ui_out *uiout);
 631
 632   ~buffered_streams ()
 633   {
 634     this->remove_buffers ();
 635   }
 636
 637   /* Remove buffering_files from all underlying streams.  */
 638   void remove_buffers ();
 639
 640 private:
 641
 642   /* True if buffers are still attached to each underlying output stream.  */
 643   bool m_buffers_in_place;
 644
 645   /* Buffers for each gdb_std* output stream.  */
 646   buffering_file m_buffered_stdout;
 647   buffering_file m_buffered_stderr;
 648   buffering_file m_buffered_stdlog;
 649   buffering_file m_buffered_stdtarg;
 650
 651   /* Buffer for current_uiout's output stream.  */
 652   std::optional<buffering_file> m_buffered_current_uiout;
 653
 654   /* Additional ui_out being buffered.  */
 655   ui_out *m_uiout;
 656
 657   /* Buffer for m_uiout's output stream.  */
 658   std::optional<buffering_file> m_buffered_uiout;
 659 };
 660
 661 #endif /* GDB_UI_OUT_H */