gdb/cli-out.c

   1 /* Output generating routines for GDB CLI.
   2
   3    Copyright (C) 1999-2015 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 #include "defs.h"
  24 #include "ui-out.h"
  25 #include "cli-out.h"
  26 #include "completer.h"
  27 #include "vec.h"
  28 #include "readline/readline.h"
  29
  30 typedef struct cli_ui_out_data cli_out_data;
  31
  32 /* Prototypes for local functions */
  33
  34 static void cli_text (struct ui_out *uiout, const char *string);
  35
  36 static void field_separator (void);
  37
  38 static void out_field_fmt (struct ui_out *uiout, int fldno,
  39                            const char *fldname,
  40                            const char *format,...) ATTRIBUTE_PRINTF (4, 5);
  41
  42 /* The destructor.  */
  43
  44 static void
  45 cli_uiout_dtor (struct ui_out *ui_out)
  46 {
  47   cli_out_data *data = ui_out_data (ui_out);
  48
  49   VEC_free (ui_filep, data->streams);
  50   xfree (data);
  51 }
  52
  53 /* These are the CLI output functions */
  54
  55 /* Mark beginning of a table */
  56
  57 static void
  58 cli_table_begin (struct ui_out *uiout, int nbrofcols,
  59                  int nr_rows,
  60                  const char *tblid)
  61 {
  62   cli_out_data *data = ui_out_data (uiout);
  63
  64   if (nr_rows == 0)
  65     data->suppress_output = 1;
  66   else
  67     /* Only the table suppresses the output and, fortunately, a table
  68        is not a recursive data structure.  */
  69     gdb_assert (data->suppress_output == 0);
  70 }
  71
  72 /* Mark beginning of a table body */
  73
  74 static void
  75 cli_table_body (struct ui_out *uiout)
  76 {
  77   cli_out_data *data = ui_out_data (uiout);
  78
  79   if (data->suppress_output)
  80     return;
  81   /* first, close the table header line */
  82   cli_text (uiout, "\n");
  83 }
  84
  85 /* Mark end of a table */
  86
  87 static void
  88 cli_table_end (struct ui_out *uiout)
  89 {
  90   cli_out_data *data = ui_out_data (uiout);
  91
  92   data->suppress_output = 0;
  93 }
  94
  95 /* Specify table header */
  96
  97 static void
  98 cli_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
  99                   const char *col_name,
 100                   const char *colhdr)
 101 {
 102   cli_out_data *data = ui_out_data (uiout);
 103
 104   if (data->suppress_output)
 105     return;
 106
 107   /* Always go through the function pointer (virtual function call).
 108      We may have been extended.  */
 109   uo_field_string (uiout, 0, width, alignment, 0, colhdr);
 110 }
 111
 112 /* Mark beginning of a list */
 113
 114 static void
 115 cli_begin (struct ui_out *uiout,
 116            enum ui_out_type type,
 117            int level,
 118            const char *id)
 119 {
 120   cli_out_data *data = ui_out_data (uiout);
 121
 122   if (data->suppress_output)
 123     return;
 124 }
 125
 126 /* Mark end of a list */
 127
 128 static void
 129 cli_end (struct ui_out *uiout,
 130          enum ui_out_type type,
 131          int level)
 132 {
 133   cli_out_data *data = ui_out_data (uiout);
 134
 135   if (data->suppress_output)
 136     return;
 137 }
 138
 139 /* output an int field */
 140
 141 static void
 142 cli_field_int (struct ui_out *uiout, int fldno, int width,
 143                enum ui_align alignment,
 144                const char *fldname, int value)
 145 {
 146   char buffer[20];      /* FIXME: how many chars long a %d can become? */
 147   cli_out_data *data = ui_out_data (uiout);
 148
 149   if (data->suppress_output)
 150     return;
 151   xsnprintf (buffer, sizeof (buffer), "%d", value);
 152
 153   /* Always go through the function pointer (virtual function call).
 154      We may have been extended.  */
 155   uo_field_string (uiout, fldno, width, alignment, fldname, buffer);
 156 }
 157
 158 /* used to ommit a field */
 159
 160 static void
 161 cli_field_skip (struct ui_out *uiout, int fldno, int width,
 162                 enum ui_align alignment,
 163                 const char *fldname)
 164 {
 165   cli_out_data *data = ui_out_data (uiout);
 166
 167   if (data->suppress_output)
 168     return;
 169
 170   /* Always go through the function pointer (virtual function call).
 171      We may have been extended.  */
 172   uo_field_string (uiout, fldno, width, alignment, fldname, "");
 173 }
 174
 175 /* other specific cli_field_* end up here so alignment and field
 176    separators are both handled by cli_field_string */
 177
 178 static void
 179 cli_field_string (struct ui_out *uiout,
 180                   int fldno,
 181                   int width,
 182                   enum ui_align align,
 183                   const char *fldname,
 184                   const char *string)
 185 {
 186   int before = 0;
 187   int after = 0;
 188   cli_out_data *data = ui_out_data (uiout);
 189
 190   if (data->suppress_output)
 191     return;
 192
 193   if ((align != ui_noalign) && string)
 194     {
 195       before = width - strlen (string);
 196       if (before <= 0)
 197         before = 0;
 198       else
 199         {
 200           if (align == ui_right)
 201             after = 0;
 202           else if (align == ui_left)
 203             {
 204               after = before;
 205               before = 0;
 206             }
 207           else
 208             /* ui_center */
 209             {
 210               after = before / 2;
 211               before -= after;
 212             }
 213         }
 214     }
 215
 216   if (before)
 217     ui_out_spaces (uiout, before);
 218   if (string)
 219     out_field_fmt (uiout, fldno, fldname, "%s", string);
 220   if (after)
 221     ui_out_spaces (uiout, after);
 222
 223   if (align != ui_noalign)
 224     field_separator ();
 225 }
 226
 227 /* This is the only field function that does not align.  */
 228
 229 static void ATTRIBUTE_PRINTF (6, 0)
 230 cli_field_fmt (struct ui_out *uiout, int fldno,
 231                int width, enum ui_align align,
 232                const char *fldname,
 233                const char *format,
 234                va_list args)
 235 {
 236   cli_out_data *data = ui_out_data (uiout);
 237   struct ui_file *stream;
 238
 239   if (data->suppress_output)
 240     return;
 241
 242   stream = VEC_last (ui_filep, data->streams);
 243   vfprintf_filtered (stream, format, args);
 244
 245   if (align != ui_noalign)
 246     field_separator ();
 247 }
 248
 249 static void
 250 cli_spaces (struct ui_out *uiout, int numspaces)
 251 {
 252   cli_out_data *data = ui_out_data (uiout);
 253   struct ui_file *stream;
 254
 255   if (data->suppress_output)
 256     return;
 257
 258   stream = VEC_last (ui_filep, data->streams);
 259   print_spaces_filtered (numspaces, stream);
 260 }
 261
 262 static void
 263 cli_text (struct ui_out *uiout, const char *string)
 264 {
 265   cli_out_data *data = ui_out_data (uiout);
 266   struct ui_file *stream;
 267
 268   if (data->suppress_output)
 269     return;
 270
 271   stream = VEC_last (ui_filep, data->streams);
 272   fputs_filtered (string, stream);
 273 }
 274
 275 static void ATTRIBUTE_PRINTF (3, 0)
 276 cli_message (struct ui_out *uiout, int verbosity,
 277              const char *format, va_list args)
 278 {
 279   cli_out_data *data = ui_out_data (uiout);
 280
 281   if (data->suppress_output)
 282     return;
 283
 284   if (ui_out_get_verblvl (uiout) >= verbosity)
 285     {
 286       struct ui_file *stream = VEC_last (ui_filep, data->streams);
 287
 288       vfprintf_unfiltered (stream, format, args);
 289     }
 290 }
 291
 292 static void
 293 cli_wrap_hint (struct ui_out *uiout, char *identstring)
 294 {
 295   cli_out_data *data = ui_out_data (uiout);
 296
 297   if (data->suppress_output)
 298     return;
 299   wrap_here (identstring);
 300 }
 301
 302 static void
 303 cli_flush (struct ui_out *uiout)
 304 {
 305   cli_out_data *data = ui_out_data (uiout);
 306   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 307
 308   gdb_flush (stream);
 309 }
 310
 311 /* OUTSTREAM as non-NULL will push OUTSTREAM on the stack of output streams
 312    and make it therefore active.  OUTSTREAM as NULL will pop the last pushed
 313    output stream; it is an internal error if it does not exist.  */
 314
 315 static int
 316 cli_redirect (struct ui_out *uiout, struct ui_file *outstream)
 317 {
 318   cli_out_data *data = ui_out_data (uiout);
 319
 320   if (outstream != NULL)
 321     VEC_safe_push (ui_filep, data->streams, outstream);
 322   else
 323     VEC_pop (ui_filep, data->streams);
 324
 325   return 0;
 326 }
 327
 328 /* local functions */
 329
 330 /* Like cli_field_fmt, but takes a variable number of args
 331    and makes a va_list and does not insert a separator.  */
 332
 333 /* VARARGS */
 334 static void
 335 out_field_fmt (struct ui_out *uiout, int fldno,
 336                const char *fldname,
 337                const char *format,...)
 338 {
 339   cli_out_data *data = ui_out_data (uiout);
 340   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 341   va_list args;
 342
 343   va_start (args, format);
 344   vfprintf_filtered (stream, format, args);
 345
 346   va_end (args);
 347 }
 348
 349 /* Access to ui_out format private members.  */
 350
 351 static void
 352 field_separator (void)
 353 {
 354   cli_out_data *data = ui_out_data (current_uiout);
 355   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 356
 357   fputc_filtered (' ', stream);
 358 }
 359
 360 /* This is the CLI ui-out implementation functions vector */
 361
 362 const struct ui_out_impl cli_ui_out_impl =
 363 {
 364   cli_table_begin,
 365   cli_table_body,
 366   cli_table_end,
 367   cli_table_header,
 368   cli_begin,
 369   cli_end,
 370   cli_field_int,
 371   cli_field_skip,
 372   cli_field_string,
 373   cli_field_fmt,
 374   cli_spaces,
 375   cli_text,
 376   cli_message,
 377   cli_wrap_hint,
 378   cli_flush,
 379   cli_redirect,
 380   cli_uiout_dtor,
 381   0, /* Does not need MI hacks (i.e. needs CLI hacks).  */
 382 };
 383
 384 /* Constructor for a `cli_out_data' object.  */
 385
 386 void
 387 cli_out_data_ctor (cli_out_data *self, struct ui_file *stream)
 388 {
 389   gdb_assert (stream != NULL);
 390
 391   self->streams = NULL;
 392   VEC_safe_push (ui_filep, self->streams, stream);
 393
 394   self->suppress_output = 0;
 395 }
 396
 397 /* Initialize private members at startup.  */
 398
 399 struct ui_out *
 400 cli_out_new (struct ui_file *stream)
 401 {
 402   int flags = ui_source_list;
 403   cli_out_data *data = XNEW (cli_out_data);
 404
 405   cli_out_data_ctor (data, stream);
 406   return ui_out_new (&cli_ui_out_impl, data, flags);
 407 }
 408
 409 struct ui_file *
 410 cli_out_set_stream (struct ui_out *uiout, struct ui_file *stream)
 411 {
 412   cli_out_data *data = ui_out_data (uiout);
 413   struct ui_file *old;
 414
 415   old = VEC_pop (ui_filep, data->streams);
 416   VEC_quick_push (ui_filep, data->streams, stream);
 417
 418   return old;
 419 }
 420 \f
 421 /* CLI interface to display tab-completion matches.  */
 422
 423 /* CLI version of displayer.crlf.  */
 424
 425 static void
 426 cli_mld_crlf (const struct match_list_displayer *displayer)
 427 {
 428   rl_crlf ();
 429 }
 430
 431 /* CLI version of displayer.putch.  */
 432
 433 static void
 434 cli_mld_putch (const struct match_list_displayer *displayer, int ch)
 435 {
 436   putc (ch, rl_outstream);
 437 }
 438
 439 /* CLI version of displayer.puts.  */
 440
 441 static void
 442 cli_mld_puts (const struct match_list_displayer *displayer, const char *s)
 443 {
 444   fputs (s, rl_outstream);
 445 }
 446
 447 /* CLI version of displayer.flush.  */
 448
 449 static void
 450 cli_mld_flush (const struct match_list_displayer *displayer)
 451 {
 452   fflush (rl_outstream);
 453 }
 454
 455 EXTERN_C void _rl_erase_entire_line (void);
 456
 457 /* CLI version of displayer.erase_entire_line.  */
 458
 459 static void
 460 cli_mld_erase_entire_line (const struct match_list_displayer *displayer)
 461 {
 462   _rl_erase_entire_line ();
 463 }
 464
 465 /* CLI version of displayer.beep.  */
 466
 467 static void
 468 cli_mld_beep (const struct match_list_displayer *displayer)
 469 {
 470   rl_ding ();
 471 }
 472
 473 /* CLI version of displayer.read_key.  */
 474
 475 static int
 476 cli_mld_read_key (const struct match_list_displayer *displayer)
 477 {
 478   return rl_read_key ();
 479 }
 480
 481 /* CLI version of rl_completion_display_matches_hook.
 482    See gdb_display_match_list for a description of the arguments.  */
 483
 484 void
 485 cli_display_match_list (char **matches, int len, int max)
 486 {
 487   struct match_list_displayer displayer;
 488
 489   rl_get_screen_size (&displayer.height, &displayer.width);
 490   displayer.crlf = cli_mld_crlf;
 491   displayer.putch = cli_mld_putch;
 492   displayer.puts = cli_mld_puts;
 493   displayer.flush = cli_mld_flush;
 494   displayer.erase_entire_line = cli_mld_erase_entire_line;
 495   displayer.beep = cli_mld_beep;
 496   displayer.read_key = cli_mld_read_key;
 497
 498   gdb_display_match_list (matches, len, max, &displayer);
 499   rl_forced_update_display ();
 500 }