gdb/cli-out.c

   1 /* Output generating routines for GDB CLI.
   2
   3    Copyright (C) 1999, 2000, 2002, 2003, 2005, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Solutions.
   7    Written by Fernando Nasser for Cygnus.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "ui-out.h"
  26 #include "cli-out.h"
  27 #include "gdb_string.h"
  28 #include "gdb_assert.h"
  29
  30 typedef struct cli_ui_out_data cli_out_data;
  31
  32 /* These are the CLI output functions */
  33
  34 static void cli_table_begin (struct ui_out *uiout, int nbrofcols,
  35                              int nr_rows, const char *tblid);
  36 static void cli_table_body (struct ui_out *uiout);
  37 static void cli_table_end (struct ui_out *uiout);
  38 static void cli_table_header (struct ui_out *uiout, int width,
  39                               enum ui_align alig, const char *col_name,
  40                               const char *colhdr);
  41 static void cli_begin (struct ui_out *uiout, enum ui_out_type type,
  42                        int level, const char *lstid);
  43 static void cli_end (struct ui_out *uiout, enum ui_out_type type, int level);
  44 static void cli_field_int (struct ui_out *uiout, int fldno, int width,
  45                            enum ui_align alig, const char *fldname, int value);
  46 static void cli_field_skip (struct ui_out *uiout, int fldno, int width,
  47                             enum ui_align alig, const char *fldname);
  48 static void cli_field_string (struct ui_out *uiout, int fldno, int width,
  49                               enum ui_align alig, const char *fldname,
  50                               const char *string);
  51 static void cli_field_fmt (struct ui_out *uiout, int fldno,
  52                            int width, enum ui_align align,
  53                            const char *fldname, const char *format,
  54                            va_list args) ATTR_FORMAT (printf, 6, 0);
  55 static void cli_spaces (struct ui_out *uiout, int numspaces);
  56 static void cli_text (struct ui_out *uiout, const char *string);
  57 static void cli_message (struct ui_out *uiout, int verbosity,
  58                          const char *format, va_list args)
  59      ATTR_FORMAT (printf, 3, 0);
  60 static void cli_wrap_hint (struct ui_out *uiout, char *identstring);
  61 static void cli_flush (struct ui_out *uiout);
  62 static int cli_redirect (struct ui_out *uiout, struct ui_file *outstream);
  63
  64 /* This is the CLI ui-out implementation functions vector */
  65
  66 /* FIXME: This can be initialized dynamically after default is set to
  67    handle initial output in main.c */
  68
  69 struct ui_out_impl cli_ui_out_impl =
  70 {
  71   cli_table_begin,
  72   cli_table_body,
  73   cli_table_end,
  74   cli_table_header,
  75   cli_begin,
  76   cli_end,
  77   cli_field_int,
  78   cli_field_skip,
  79   cli_field_string,
  80   cli_field_fmt,
  81   cli_spaces,
  82   cli_text,
  83   cli_message,
  84   cli_wrap_hint,
  85   cli_flush,
  86   cli_redirect,
  87   0, /* Does not need MI hacks (i.e. needs CLI hacks).  */
  88 };
  89
  90 /* Prototypes for local functions */
  91
  92 extern void _initialize_cli_out (void);
  93
  94 static void field_separator (void);
  95
  96 static void out_field_fmt (struct ui_out *uiout, int fldno,
  97                            const char *fldname,
  98                            const char *format,...) ATTR_FORMAT (printf, 4, 5);
  99
 100 /* Mark beginning of a table */
 101
 102 void
 103 cli_table_begin (struct ui_out *uiout, int nbrofcols,
 104                  int nr_rows,
 105                  const char *tblid)
 106 {
 107   cli_out_data *data = ui_out_data (uiout);
 108   if (nr_rows == 0)
 109     data->suppress_output = 1;
 110   else
 111     /* Only the table suppresses the output and, fortunately, a table
 112        is not a recursive data structure.  */
 113     gdb_assert (data->suppress_output == 0);
 114 }
 115
 116 /* Mark beginning of a table body */
 117
 118 void
 119 cli_table_body (struct ui_out *uiout)
 120 {
 121   cli_out_data *data = ui_out_data (uiout);
 122   if (data->suppress_output)
 123     return;
 124   /* first, close the table header line */
 125   cli_text (uiout, "\n");
 126 }
 127
 128 /* Mark end of a table */
 129
 130 void
 131 cli_table_end (struct ui_out *uiout)
 132 {
 133   cli_out_data *data = ui_out_data (uiout);
 134   data->suppress_output = 0;
 135 }
 136
 137 /* Specify table header */
 138
 139 void
 140 cli_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
 141                   const char *col_name,
 142                   const char *colhdr)
 143 {
 144   cli_out_data *data = ui_out_data (uiout);
 145   if (data->suppress_output)
 146     return;
 147
 148   /* Always go through the function pointer (virtual function call).
 149      We may have been extended.  */
 150   uo_field_string (uiout, 0, width, alignment, 0, colhdr);
 151 }
 152
 153 /* Mark beginning of a list */
 154
 155 void
 156 cli_begin (struct ui_out *uiout,
 157            enum ui_out_type type,
 158            int level,
 159            const char *id)
 160 {
 161   cli_out_data *data = ui_out_data (uiout);
 162   if (data->suppress_output)
 163     return;
 164 }
 165
 166 /* Mark end of a list */
 167
 168 void
 169 cli_end (struct ui_out *uiout,
 170          enum ui_out_type type,
 171          int level)
 172 {
 173   cli_out_data *data = ui_out_data (uiout);
 174   if (data->suppress_output)
 175     return;
 176 }
 177
 178 /* output an int field */
 179
 180 void
 181 cli_field_int (struct ui_out *uiout, int fldno, int width,
 182                enum ui_align alignment,
 183                const char *fldname, int value)
 184 {
 185   char buffer[20];              /* FIXME: how many chars long a %d can become? */
 186
 187   cli_out_data *data = ui_out_data (uiout);
 188   if (data->suppress_output)
 189     return;
 190   sprintf (buffer, "%d", value);
 191
 192   /* Always go through the function pointer (virtual function call).
 193      We may have been extended.  */
 194   uo_field_string (uiout, fldno, width, alignment, fldname, buffer);
 195 }
 196
 197 /* used to ommit a field */
 198
 199 void
 200 cli_field_skip (struct ui_out *uiout, int fldno, int width,
 201                 enum ui_align alignment,
 202                 const char *fldname)
 203 {
 204   cli_out_data *data = ui_out_data (uiout);
 205   if (data->suppress_output)
 206     return;
 207
 208   /* Always go through the function pointer (virtual function call).
 209      We may have been extended.  */
 210   uo_field_string (uiout, fldno, width, alignment, fldname, "");
 211 }
 212
 213 /* other specific cli_field_* end up here so alignment and field
 214    separators are both handled by cli_field_string */
 215
 216 void
 217 cli_field_string (struct ui_out *uiout,
 218                   int fldno,
 219                   int width,
 220                   enum ui_align align,
 221                   const char *fldname,
 222                   const char *string)
 223 {
 224   int before = 0;
 225   int after = 0;
 226
 227   cli_out_data *data = ui_out_data (uiout);
 228   if (data->suppress_output)
 229     return;
 230
 231   if ((align != ui_noalign) && string)
 232     {
 233       before = width - strlen (string);
 234       if (before <= 0)
 235         before = 0;
 236       else
 237         {
 238           if (align == ui_right)
 239             after = 0;
 240           else if (align == ui_left)
 241             {
 242               after = before;
 243               before = 0;
 244             }
 245           else
 246             /* ui_center */
 247             {
 248               after = before / 2;
 249               before -= after;
 250             }
 251         }
 252     }
 253
 254   if (before)
 255     ui_out_spaces (uiout, before);
 256   if (string)
 257     out_field_fmt (uiout, fldno, fldname, "%s", string);
 258   if (after)
 259     ui_out_spaces (uiout, after);
 260
 261   if (align != ui_noalign)
 262     field_separator ();
 263 }
 264
 265 /* This is the only field function that does not align.  */
 266
 267 void
 268 cli_field_fmt (struct ui_out *uiout, int fldno,
 269                int width, enum ui_align align,
 270                const char *fldname,
 271                const char *format,
 272                va_list args)
 273 {
 274   cli_out_data *data = ui_out_data (uiout);
 275   if (data->suppress_output)
 276     return;
 277
 278   vfprintf_filtered (data->stream, format, args);
 279
 280   if (align != ui_noalign)
 281     field_separator ();
 282 }
 283
 284 void
 285 cli_spaces (struct ui_out *uiout, int numspaces)
 286 {
 287   cli_out_data *data = ui_out_data (uiout);
 288   if (data->suppress_output)
 289     return;
 290   print_spaces_filtered (numspaces, data->stream);
 291 }
 292
 293 void
 294 cli_text (struct ui_out *uiout, const char *string)
 295 {
 296   cli_out_data *data = ui_out_data (uiout);
 297   if (data->suppress_output)
 298     return;
 299   fputs_filtered (string, data->stream);
 300 }
 301
 302 void
 303 cli_message (struct ui_out *uiout, int verbosity,
 304              const char *format, va_list args)
 305 {
 306   cli_out_data *data = ui_out_data (uiout);
 307   if (data->suppress_output)
 308     return;
 309   if (ui_out_get_verblvl (uiout) >= verbosity)
 310     vfprintf_unfiltered (data->stream, format, args);
 311 }
 312
 313 void
 314 cli_wrap_hint (struct ui_out *uiout, char *identstring)
 315 {
 316   cli_out_data *data = ui_out_data (uiout);
 317   if (data->suppress_output)
 318     return;
 319   wrap_here (identstring);
 320 }
 321
 322 void
 323 cli_flush (struct ui_out *uiout)
 324 {
 325   cli_out_data *data = ui_out_data (uiout);
 326   gdb_flush (data->stream);
 327 }
 328
 329 int
 330 cli_redirect (struct ui_out *uiout, struct ui_file *outstream)
 331 {
 332   cli_out_data *data = ui_out_data (uiout);
 333   if (outstream != NULL)
 334     {
 335       data->original_stream = data->stream;
 336       data->stream = outstream;
 337     }
 338   else if (data->original_stream != NULL)
 339     {
 340       data->stream = data->original_stream;
 341       data->original_stream = NULL;
 342     }
 343
 344   return 0;
 345 }
 346
 347 /* local functions */
 348
 349 /* Like cli_field_fmt, but takes a variable number of args
 350    and makes a va_list and does not insert a separator.  */
 351
 352 /* VARARGS */
 353 static void
 354 out_field_fmt (struct ui_out *uiout, int fldno,
 355                const char *fldname,
 356                const char *format,...)
 357 {
 358   cli_out_data *data = ui_out_data (uiout);
 359   va_list args;
 360
 361   va_start (args, format);
 362   vfprintf_filtered (data->stream, format, args);
 363
 364   va_end (args);
 365 }
 366
 367 /* Access to ui_out format private members.  */
 368
 369 static void
 370 field_separator (void)
 371 {
 372   cli_out_data *data = ui_out_data (uiout);
 373   fputc_filtered (' ', data->stream);
 374 }
 375
 376 /* Constructor for a `cli_out_data' object.  */
 377
 378 void
 379 cli_out_data_ctor (cli_out_data *self, struct ui_file *stream)
 380 {
 381   self->stream = stream;
 382   self->original_stream = NULL;
 383   self->suppress_output = 0;
 384 }
 385
 386 /* Initialize private members at startup.  */
 387
 388 struct ui_out *
 389 cli_out_new (struct ui_file *stream)
 390 {
 391   int flags = ui_source_list;
 392
 393   cli_out_data *data = XMALLOC (cli_out_data);
 394   cli_out_data_ctor (data, stream);
 395   return ui_out_new (&cli_ui_out_impl, data, flags);
 396 }
 397
 398 struct ui_file *
 399 cli_out_set_stream (struct ui_out *uiout, struct ui_file *stream)
 400 {
 401   cli_out_data *data = ui_out_data (uiout);
 402   struct ui_file *old = data->stream;
 403   data->stream = stream;
 404   return old;
 405 }
 406
 407 /* Standard gdb initialization hook.  */
 408 void
 409 _initialize_cli_out (void)
 410 {
 411   /* nothing needs to be done */
 412 }