gdb/cli-out.c

   1 /* Output generating routines for GDB CLI.
   2
   3    Copyright (C) 1999-2016 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 = (cli_out_data *) ui_out_data (ui_out);
  48
  49   VEC_free (ui_filep, data->streams);
  50   delete 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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 = (cli_out_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 (2, 0)
 276 cli_message (struct ui_out *uiout, const char *format, va_list args)
 277 {
 278   cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
 279
 280   if (data->suppress_output)
 281     return;
 282
 283   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 284   vfprintf_unfiltered (stream, format, args);
 285 }
 286
 287 static void
 288 cli_wrap_hint (struct ui_out *uiout, const char *identstring)
 289 {
 290   cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
 291
 292   if (data->suppress_output)
 293     return;
 294   wrap_here (identstring);
 295 }
 296
 297 static void
 298 cli_flush (struct ui_out *uiout)
 299 {
 300   cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
 301   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 302
 303   gdb_flush (stream);
 304 }
 305
 306 /* OUTSTREAM as non-NULL will push OUTSTREAM on the stack of output streams
 307    and make it therefore active.  OUTSTREAM as NULL will pop the last pushed
 308    output stream; it is an internal error if it does not exist.  */
 309
 310 static int
 311 cli_redirect (struct ui_out *uiout, struct ui_file *outstream)
 312 {
 313   cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
 314
 315   if (outstream != NULL)
 316     VEC_safe_push (ui_filep, data->streams, outstream);
 317   else
 318     VEC_pop (ui_filep, data->streams);
 319
 320   return 0;
 321 }
 322
 323 /* local functions */
 324
 325 /* Like cli_field_fmt, but takes a variable number of args
 326    and makes a va_list and does not insert a separator.  */
 327
 328 /* VARARGS */
 329 static void
 330 out_field_fmt (struct ui_out *uiout, int fldno,
 331                const char *fldname,
 332                const char *format,...)
 333 {
 334   cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
 335   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 336   va_list args;
 337
 338   va_start (args, format);
 339   vfprintf_filtered (stream, format, args);
 340
 341   va_end (args);
 342 }
 343
 344 /* Access to ui_out format private members.  */
 345
 346 static void
 347 field_separator (void)
 348 {
 349   cli_out_data *data = (cli_out_data *) ui_out_data (current_uiout);
 350   struct ui_file *stream = VEC_last (ui_filep, data->streams);
 351
 352   fputc_filtered (' ', stream);
 353 }
 354
 355 /* This is the CLI ui-out implementation functions vector */
 356
 357 const struct ui_out_impl cli_ui_out_impl =
 358 {
 359   cli_table_begin,
 360   cli_table_body,
 361   cli_table_end,
 362   cli_table_header,
 363   cli_begin,
 364   cli_end,
 365   cli_field_int,
 366   cli_field_skip,
 367   cli_field_string,
 368   cli_field_fmt,
 369   cli_spaces,
 370   cli_text,
 371   cli_message,
 372   cli_wrap_hint,
 373   cli_flush,
 374   cli_redirect,
 375   cli_uiout_dtor,
 376   0, /* Does not need MI hacks (i.e. needs CLI hacks).  */
 377 };
 378
 379 /* Constructor for a `cli_out_data' object.  */
 380
 381 void
 382 cli_out_data_ctor (cli_out_data *self, struct ui_file *stream)
 383 {
 384   gdb_assert (stream != NULL);
 385
 386   self->streams = NULL;
 387   VEC_safe_push (ui_filep, self->streams, stream);
 388
 389   self->suppress_output = 0;
 390 }
 391
 392 /* Initialize private members at startup.  */
 393
 394 struct ui_out *
 395 cli_out_new (struct ui_file *stream)
 396 {
 397   int flags = ui_source_list;
 398   cli_out_data *data = new cli_out_data ();
 399
 400   cli_out_data_ctor (data, stream);
 401   return ui_out_new (&cli_ui_out_impl, data, flags);
 402 }
 403
 404 struct ui_file *
 405 cli_out_set_stream (struct ui_out *uiout, struct ui_file *stream)
 406 {
 407   cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
 408   struct ui_file *old;
 409
 410   old = VEC_pop (ui_filep, data->streams);
 411   VEC_quick_push (ui_filep, data->streams, stream);
 412
 413   return old;
 414 }
 415 \f
 416 /* CLI interface to display tab-completion matches.  */
 417
 418 /* CLI version of displayer.crlf.  */
 419
 420 static void
 421 cli_mld_crlf (const struct match_list_displayer *displayer)
 422 {
 423   rl_crlf ();
 424 }
 425
 426 /* CLI version of displayer.putch.  */
 427
 428 static void
 429 cli_mld_putch (const struct match_list_displayer *displayer, int ch)
 430 {
 431   putc (ch, rl_outstream);
 432 }
 433
 434 /* CLI version of displayer.puts.  */
 435
 436 static void
 437 cli_mld_puts (const struct match_list_displayer *displayer, const char *s)
 438 {
 439   fputs (s, rl_outstream);
 440 }
 441
 442 /* CLI version of displayer.flush.  */
 443
 444 static void
 445 cli_mld_flush (const struct match_list_displayer *displayer)
 446 {
 447   fflush (rl_outstream);
 448 }
 449
 450 EXTERN_C void _rl_erase_entire_line (void);
 451
 452 /* CLI version of displayer.erase_entire_line.  */
 453
 454 static void
 455 cli_mld_erase_entire_line (const struct match_list_displayer *displayer)
 456 {
 457   _rl_erase_entire_line ();
 458 }
 459
 460 /* CLI version of displayer.beep.  */
 461
 462 static void
 463 cli_mld_beep (const struct match_list_displayer *displayer)
 464 {
 465   rl_ding ();
 466 }
 467
 468 /* CLI version of displayer.read_key.  */
 469
 470 static int
 471 cli_mld_read_key (const struct match_list_displayer *displayer)
 472 {
 473   return rl_read_key ();
 474 }
 475
 476 /* CLI version of rl_completion_display_matches_hook.
 477    See gdb_display_match_list for a description of the arguments.  */
 478
 479 void
 480 cli_display_match_list (char **matches, int len, int max)
 481 {
 482   struct match_list_displayer displayer;
 483
 484   rl_get_screen_size (&displayer.height, &displayer.width);
 485   displayer.crlf = cli_mld_crlf;
 486   displayer.putch = cli_mld_putch;
 487   displayer.puts = cli_mld_puts;
 488   displayer.flush = cli_mld_flush;
 489   displayer.erase_entire_line = cli_mld_erase_entire_line;
 490   displayer.beep = cli_mld_beep;
 491   displayer.read_key = cli_mld_read_key;
 492
 493   gdb_display_match_list (matches, len, max, &displayer);
 494   rl_forced_update_display ();
 495 }