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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [typeprint.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Language independent support for printing types for GDB, the GNU debugger.
2
   Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1998, 1999,
3
   2000 Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include "defs.h"
23
#include "obstack.h"
24
#include "bfd.h"                /* Binary File Description */
25
#include "symtab.h"
26
#include "gdbtypes.h"
27
#include "expression.h"
28
#include "value.h"
29
#include "gdbcore.h"
30
#include "command.h"
31
#include "gdbcmd.h"
32
#include "target.h"
33
#include "language.h"
34
#include "cp-abi.h"
35
 
36
#include "gdb_string.h"
37
#include <errno.h>
38
 
39
/* For real-type printing in whatis_exp() */
40
extern int objectprint;         /* Controls looking up an object's derived type
41
                                   using what we find in its vtables.  */
42
 
43
extern void _initialize_typeprint (void);
44
 
45
static void ptype_command (char *, int);
46
 
47
static struct type *ptype_eval (struct expression *);
48
 
49
static void whatis_command (char *, int);
50
 
51
static void whatis_exp (char *, int);
52
 
53
/* Print a description of a type in the format of a
54
   typedef for the current language.
55
   NEW is the new name for a type TYPE. */
56
 
57
void
58
typedef_print (struct type *type, struct symbol *new, struct ui_file *stream)
59
{
60
  CHECK_TYPEDEF (type);
61
  switch (current_language->la_language)
62
    {
63
#ifdef _LANG_c
64
    case language_c:
65
    case language_cplus:
66
      fprintf_filtered (stream, "typedef ");
67
      type_print (type, "", stream, 0);
68
      if (TYPE_NAME ((SYMBOL_TYPE (new))) == 0
69
          || !STREQ (TYPE_NAME ((SYMBOL_TYPE (new))), SYMBOL_NAME (new)))
70
        fprintf_filtered (stream, " %s", SYMBOL_SOURCE_NAME (new));
71
      break;
72
#endif
73
#ifdef _LANG_m2
74
    case language_m2:
75
      fprintf_filtered (stream, "TYPE ");
76
      if (!TYPE_NAME (SYMBOL_TYPE (new)) ||
77
          !STREQ (TYPE_NAME (SYMBOL_TYPE (new)), SYMBOL_NAME (new)))
78
        fprintf_filtered (stream, "%s = ", SYMBOL_SOURCE_NAME (new));
79
      else
80
        fprintf_filtered (stream, "<builtin> = ");
81
      type_print (type, "", stream, 0);
82
      break;
83
#endif
84
#ifdef _LANG_pascal
85
    case language_pascal:
86
      fprintf_filtered (stream, "type ");
87
      fprintf_filtered (stream, "%s = ", SYMBOL_SOURCE_NAME (new));
88
      type_print (type, "", stream, 0);
89
      break;
90
#endif
91
#ifdef _LANG_chill
92
    case language_chill:
93
      fprintf_filtered (stream, "SYNMODE ");
94
      if (!TYPE_NAME (SYMBOL_TYPE (new)) ||
95
          !STREQ (TYPE_NAME (SYMBOL_TYPE (new)), SYMBOL_NAME (new)))
96
        fprintf_filtered (stream, "%s = ", SYMBOL_SOURCE_NAME (new));
97
      else
98
        fprintf_filtered (stream, "<builtin> = ");
99
      type_print (type, "", stream, 0);
100
      break;
101
#endif
102
    default:
103
      error ("Language not supported.");
104
    }
105
  fprintf_filtered (stream, ";\n");
106
}
107
 
108
/* Print a description of a type TYPE in the form of a declaration of a
109
   variable named VARSTRING.  (VARSTRING is demangled if necessary.)
110
   Output goes to STREAM (via stdio).
111
   If SHOW is positive, we show the contents of the outermost level
112
   of structure even if there is a type name that could be used instead.
113
   If SHOW is negative, we never show the details of elements' types.  */
114
 
115
void
116
type_print (struct type *type, char *varstring, struct ui_file *stream,
117
            int show)
118
{
119
  LA_PRINT_TYPE (type, varstring, stream, show, 0);
120
}
121
 
122
/* Print type of EXP, or last thing in value history if EXP == NULL.
123
   show is passed to type_print.  */
124
 
125
static void
126
whatis_exp (char *exp, int show)
127
{
128
  struct expression *expr;
129
  register value_ptr val;
130
  register struct cleanup *old_chain = NULL;
131
  struct type *real_type = NULL;
132
  struct type *type;
133
  int full = 0;
134
  int top = -1;
135
  int using_enc = 0;
136
 
137
  if (exp)
138
    {
139
      expr = parse_expression (exp);
140
      old_chain = make_cleanup (free_current_contents, &expr);
141
      val = evaluate_type (expr);
142
    }
143
  else
144
    val = access_value_history (0);
145
 
146
  type = VALUE_TYPE (val);
147
 
148
  if (objectprint)
149
    {
150
      if (((TYPE_CODE (type) == TYPE_CODE_PTR) ||
151
           (TYPE_CODE (type) == TYPE_CODE_REF))
152
          &&
153
          (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
154
        {
155
          real_type = value_rtti_target_type (val, &full, &top, &using_enc);
156
          if (real_type)
157
            {
158
              if (TYPE_CODE (type) == TYPE_CODE_PTR)
159
                real_type = lookup_pointer_type (real_type);
160
              else
161
                real_type = lookup_reference_type (real_type);
162
            }
163
        }
164
      else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
165
  real_type = value_rtti_type (val, &full, &top, &using_enc);
166
    }
167
 
168
  printf_filtered ("type = ");
169
 
170
  if (real_type)
171
    {
172
      printf_filtered ("/* real type = ");
173
      type_print (real_type, "", gdb_stdout, -1);
174
      if (! full)
175
        printf_filtered (" (incomplete object)");
176
      printf_filtered (" */\n");
177
    }
178
 
179
  type_print (type, "", gdb_stdout, show);
180
  printf_filtered ("\n");
181
 
182
  if (exp)
183
    do_cleanups (old_chain);
184
}
185
 
186
/* ARGSUSED */
187
static void
188
whatis_command (char *exp, int from_tty)
189
{
190
  /* Most of the time users do not want to see all the fields
191
     in a structure.  If they do they can use the "ptype" command.
192
     Hence the "-1" below.  */
193
  whatis_exp (exp, -1);
194
}
195
 
196
/* Simple subroutine for ptype_command.  */
197
 
198
static struct type *
199
ptype_eval (struct expression *exp)
200
{
201
  if (exp->elts[0].opcode == OP_TYPE)
202
    {
203
      return (exp->elts[1].type);
204
    }
205
  else
206
    {
207
      return (NULL);
208
    }
209
}
210
 
211
/* TYPENAME is either the name of a type, or an expression.  */
212
 
213
/* ARGSUSED */
214
static void
215
ptype_command (char *typename, int from_tty)
216
{
217
  register struct type *type;
218
  struct expression *expr;
219
  register struct cleanup *old_chain;
220
 
221
  if (typename == NULL)
222
    {
223
      /* Print type of last thing in value history. */
224
      whatis_exp (typename, 1);
225
    }
226
  else
227
    {
228
      expr = parse_expression (typename);
229
      old_chain = make_cleanup (free_current_contents, &expr);
230
      type = ptype_eval (expr);
231
      if (type != NULL)
232
        {
233
          /* User did "ptype <typename>" */
234
          printf_filtered ("type = ");
235
          type_print (type, "", gdb_stdout, 1);
236
          printf_filtered ("\n");
237
          do_cleanups (old_chain);
238
        }
239
      else
240
        {
241
          /* User did "ptype <symbolname>" */
242
          do_cleanups (old_chain);
243
          whatis_exp (typename, 1);
244
        }
245
    }
246
}
247
 
248
/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
249
   Used to print data from type structures in a specified type.  For example,
250
   array bounds may be characters or booleans in some languages, and this
251
   allows the ranges to be printed in their "natural" form rather than as
252
   decimal integer values.
253
 
254
   FIXME:  This is here simply because only the type printing routines
255
   currently use it, and it wasn't clear if it really belonged somewhere
256
   else (like printcmd.c).  There are a lot of other gdb routines that do
257
   something similar, but they are generally concerned with printing values
258
   that come from the inferior in target byte order and target size. */
259
 
260
void
261
print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
262
{
263
  unsigned int i;
264
  unsigned len;
265
 
266
  CHECK_TYPEDEF (type);
267
 
268
  switch (TYPE_CODE (type))
269
    {
270
 
271
    case TYPE_CODE_ENUM:
272
      len = TYPE_NFIELDS (type);
273
      for (i = 0; i < len; i++)
274
        {
275
          if (TYPE_FIELD_BITPOS (type, i) == val)
276
            {
277
              break;
278
            }
279
        }
280
      if (i < len)
281
        {
282
          fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
283
        }
284
      else
285
        {
286
          print_longest (stream, 'd', 0, val);
287
        }
288
      break;
289
 
290
    case TYPE_CODE_INT:
291
      print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
292
      break;
293
 
294
    case TYPE_CODE_CHAR:
295
      LA_PRINT_CHAR ((unsigned char) val, stream);
296
      break;
297
 
298
    case TYPE_CODE_BOOL:
299
      fprintf_filtered (stream, val ? "TRUE" : "FALSE");
300
      break;
301
 
302
    case TYPE_CODE_RANGE:
303
      print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
304
      return;
305
 
306
    case TYPE_CODE_UNDEF:
307
    case TYPE_CODE_PTR:
308
    case TYPE_CODE_ARRAY:
309
    case TYPE_CODE_STRUCT:
310
    case TYPE_CODE_UNION:
311
    case TYPE_CODE_FUNC:
312
    case TYPE_CODE_FLT:
313
    case TYPE_CODE_VOID:
314
    case TYPE_CODE_SET:
315
    case TYPE_CODE_STRING:
316
    case TYPE_CODE_ERROR:
317
    case TYPE_CODE_MEMBER:
318
    case TYPE_CODE_METHOD:
319
    case TYPE_CODE_REF:
320
      error ("internal error: unhandled type in print_type_scalar");
321
      break;
322
 
323
    default:
324
      error ("Invalid type code in symbol table.");
325
    }
326
  gdb_flush (stream);
327
}
328
 
329
/* Dump details of a type specified either directly or indirectly.
330
   Uses the same sort of type lookup mechanism as ptype_command()
331
   and whatis_command(). */
332
 
333
void
334
maintenance_print_type (char *typename, int from_tty)
335
{
336
  register value_ptr val;
337
  register struct type *type;
338
  register struct cleanup *old_chain;
339
  struct expression *expr;
340
 
341
  if (typename != NULL)
342
    {
343
      expr = parse_expression (typename);
344
      old_chain = make_cleanup (free_current_contents, &expr);
345
      if (expr->elts[0].opcode == OP_TYPE)
346
        {
347
          /* The user expression names a type directly, just use that type. */
348
          type = expr->elts[1].type;
349
        }
350
      else
351
        {
352
          /* The user expression may name a type indirectly by naming an
353
             object of that type.  Find that indirectly named type. */
354
          val = evaluate_type (expr);
355
          type = VALUE_TYPE (val);
356
        }
357
      if (type != NULL)
358
        {
359
          recursive_dump_type (type, 0);
360
        }
361
      do_cleanups (old_chain);
362
    }
363
}
364
 
365
 
366
void
367
_initialize_typeprint (void)
368
{
369
 
370
  add_com ("ptype", class_vars, ptype_command,
371
           "Print definition of type TYPE.\n\
372
Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\
373
or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\
374
The selected stack frame's lexical context is used to look up the name.");
375
 
376
  add_com ("whatis", class_vars, whatis_command,
377
           "Print data type of expression EXP.");
378
 
379
}

powered by: WebSVN 2.1.0

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