OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [cli-out.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.