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