-/* Print values for GNU debugger gdb.
- Copyright (C) 1986, 1988, 1989 Free Software Foundation, Inc.
+/* Print values for GDB, the GNU debugger.
+ Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
This file is part of GDB.
-GDB is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
-#include <string.h>
#include "defs.h"
-#include "param.h"
+#include <string.h>
#include "symtab.h"
+#include "gdbtypes.h"
#include "value.h"
#include "gdbcore.h"
#include "gdbcmd.h"
#include "target.h"
#include "obstack.h"
+#include "language.h"
+#include "demangle.h"
#include <errno.h>
-extern int sys_nerr;
-extern char *sys_errlist[];
-extern void print_scalar_formatted(); /* printcmd.c */
-extern void print_address_demangle(); /* printcmd.c */
+/* Prototypes for local functions */
+
+static void
+print_string PARAMS ((FILE *, char *, unsigned int, int));
+
+static void
+show_print PARAMS ((char *, int));
+
+static void
+set_print PARAMS ((char *, int));
+
+static void
+set_radix PARAMS ((char *, int, struct cmd_list_element *));
+
+static void
+set_output_radix PARAMS ((char *, int, struct cmd_list_element *));
+
+static void
+type_print_base PARAMS ((struct type *, FILE *, int, int));
+
+static void
+type_print_args PARAMS ((struct type *, FILE *));
+
+static void
+type_print_varspec_suffix PARAMS ((struct type *, FILE *, int, int, int));
+
+static void
+type_print_varspec_prefix PARAMS ((struct type *, FILE *, int, int));
+
+static void
+type_print_derivation_info PARAMS ((FILE *, struct type *));
+
+static void
+type_print_method_args PARAMS ((struct type **, char *, char *, int, FILE *));
+
+static void
+cplus_val_print PARAMS ((struct type *, char *, FILE *, int, int,
+ enum val_prettyprint, struct type **));
+
+static void
+val_print_fields PARAMS ((struct type *, char *, FILE *, int, int,
+ enum val_prettyprint, struct type **));
+
+static int
+is_vtbl_member PARAMS ((struct type *));
+
+static int
+is_vtbl_ptr_type PARAMS ((struct type *));
+
+static void
+print_hex_chars PARAMS ((FILE *, unsigned char *, unsigned));
+
extern int demangle; /* whether to print C++ syms raw or source-form */
/* Maximum number of chars to print for a string pointer value
static unsigned int print_max;
-static void type_print_varspec_suffix ();
-static void type_print_varspec_prefix ();
-static void type_print_base ();
-static void type_print_method_args ();
-
/* Default input and output radixes, and output format letter. */
unsigned input_radix = 10;
unsigned output_radix = 10;
int output_format = 0;
-
-char **unsigned_type_table;
-char **signed_type_table;
-char **float_type_table;
-
-
/* Print repeat counts if there are more than this
many repetitions of an element in an array. */
#define REPEAT_COUNT_THRESHOLD 10
+
+/* Define a mess of print controls. */
+
+int prettyprint; /* Controls pretty printing of structures */
+int vtblprint; /* Controls printing of vtbl's */
+int unionprint; /* Controls printing of nested unions. */
+int arrayprint; /* Controls pretty printing of arrays. */
+int addressprint; /* Controls pretty printing of addresses. */
+int objectprint; /* Controls looking up an object's derived type
+ using what we find in its vtables. */
+
+struct obstack dont_print_obstack;
+
\f
/* Print the character string STRING, printing at most LENGTH characters.
Printing stops early if the number hits print_max; repeat counts
are printed as appropriate. Print ellipses at the end if we
had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. */
-void
+static void
print_string (stream, string, length, force_ellipses)
FILE *stream;
char *string;
if (len == sizeof (float))
{
/* It's single precision. */
- bcopy (valaddr, &low, sizeof (low));
+ memcpy ((char *) &low, valaddr, sizeof (low));
/* target -> host. */
SWAP_TARGET_AND_HOST (&low, sizeof (float));
nonnegative = low >= 0;
/* It's double precision. Get the high and low words. */
#if TARGET_BYTE_ORDER == BIG_ENDIAN
- bcopy (valaddr+4, &low, sizeof (low));
- bcopy (valaddr+0, &high, sizeof (high));
+ memcpy (&low, valaddr+4, sizeof (low));
+ memcpy (&high, valaddr+0, sizeof (high));
#else
- bcopy (valaddr+0, &low, sizeof (low));
- bcopy (valaddr+4, &high, sizeof (high));
+ memcpy (&low, valaddr+0, sizeof (low));
+ memcpy (&high, valaddr+4, sizeof (high));
#endif
- SWAP_TARGET_AND_HOST (&low, sizeof (low));
- SWAP_TARGET_AND_HOST (&high, sizeof (high));
- nonnegative = high >= 0;
- is_nan = (((high >> 20) & 0x7ff) == 0x7ff
- && ! ((((high & 0xfffff) == 0)) && (low == 0)));
- high &= 0xfffff;
- }
+ SWAP_TARGET_AND_HOST (&low, sizeof (low));
+ SWAP_TARGET_AND_HOST (&high, sizeof (high));
+ nonnegative = high >= 0;
+ is_nan = (((high >> 20) & 0x7ff) == 0x7ff
+ && ! ((((high & 0xfffff) == 0)) && (low == 0)));
+ high &= 0xfffff;
+ }
if (is_nan)
{
if (inv)
fprintf_filtered (stream, "<invalid float value>");
else
- fprintf_filtered (stream, len <= sizeof(float) ? "%.6g" : "%.17g", doub);
+ fprintf_filtered (stream, len <= sizeof(float) ? "%.9g" : "%.17g", doub);
}
/* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
value_print (val, stream, format, pretty)
value val;
FILE *stream;
- char format;
+ int format;
enum val_prettyprint pretty;
{
register unsigned int i, n, typelen;
printf_filtered ("<value optimized out>");
return 0;
}
-
+
/* A "repeated" value really contains several values in a row.
They are made by the @ operator.
Print such values as if they were arrays. */
rep1 = i + 1;
reps = 1;
while (rep1 < n
- && !bcmp (VALUE_CONTENTS (val) + typelen * i,
+ && !memcmp (VALUE_CONTENTS (val) + typelen * i,
VALUE_CONTENTS (val) + typelen * rep1, typelen))
{
++reps;
}
else
{
+ struct type *type = VALUE_TYPE (val);
+
/* If it is a pointer, indicate what it points to.
Print type also if it is a reference.
C++: if it is a member pointer, we will take care
of that when we print it. */
- if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
+ if (TYPE_CODE (type) == TYPE_CODE_PTR
+ || TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Hack: remove (char *) for char strings. Their
type is indicated by the quoted string anyway. */
- if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR
- && TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val)))
- == sizeof(char)
- && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (val)))
- == TYPE_CODE_INT
- && !TYPE_UNSIGNED (TYPE_TARGET_TYPE (VALUE_TYPE (val))))
+ if (TYPE_CODE (type) == TYPE_CODE_PTR
+ && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof(char)
+ && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT
+ && !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
{
/* Print nothing */
}
else
{
fprintf_filtered (stream, "(");
- type_print (VALUE_TYPE (val), "", stream, -1);
+ type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
- return val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
+ return val_print (type, VALUE_CONTENTS (val),
VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
}
}
is_vtbl_ptr_type(type)
struct type *type;
{
- char *typename = TYPE_NAME(type);
+ char *typename = type_name_no_tag (type);
static const char vtbl_ptr_name[] =
- { CPLUS_MARKER,'v','t','b','l','_','p','t','r','_','t','y','p','e' };
+ { CPLUS_MARKER,'v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
return (typename != NULL && !strcmp(typename, vtbl_ptr_name));
}
is_vtbl_member(type)
struct type *type;
{
- if (TYPE_CODE (type) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY
- && TYPE_CODE (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type))) == TYPE_CODE_STRUCT)
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ type = TYPE_TARGET_TYPE (type);
+ else
+ return 0;
+
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)
/* Virtual functions tables are full of pointers to virtual functions. */
- return is_vtbl_ptr_type (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)));
+ return is_vtbl_ptr_type (TYPE_TARGET_TYPE (type));
return 0;
}
\f
-/* Define a mess of print controls. */
-
-int prettyprint; /* Controls pretty printing of structures */
-int vtblprint; /* Controls printing of vtbl's */
-int unionprint; /* Controls printing of nested unions. */
-int arrayprint; /* Controls pretty printing of arrays. */
-int addressprint; /* Controls pretty printing of addresses. */
-
-struct obstack dont_print_obstack;
-
-static void cplus_val_print ();
-
/* Mutually recursive subroutines of cplus_val_print and val_print to print out
a structure's fields: val_print_fields and cplus_val_print.
DONT_PRINT is an array of baseclass types that we
should not print, or zero if called from top level. */
+
static void
val_print_fields (type, valaddr, stream, format, recurse, pretty, dont_print)
struct type *type;
char *valaddr;
FILE *stream;
- char format;
+ int format;
int recurse;
enum val_prettyprint pretty;
struct type **dont_print;
{
int i, len, n_baseclasses;
+ check_stub_type (type);
+
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
fprintf_filtered (stream, ", ");
else if (n_baseclasses > 0)
{
- fprintf_filtered (stream, "\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
- fputs_filtered ("members of ", stream);
- fputs_filtered (type_name_no_tag (type), stream);
- fputs_filtered (": ", stream);
+ if (pretty)
+ {
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 + 2 * recurse, stream);
+ fputs_filtered ("members of ", stream);
+ fputs_filtered (type_name_no_tag (type), stream);
+ fputs_filtered (": ", stream);
+ }
}
fields_seen = 1;
fputs_filtered ("\"( ptr \"", stream);
else
fputs_filtered ("\"( nodef \"", stream);
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
+ fprint_symbol (stream, TYPE_FIELD_NAME (type, i));
fputs_filtered ("\" \"", stream);
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
+ fprint_symbol (stream, TYPE_FIELD_NAME (type, i));
fputs_filtered ("\") \"", stream);
}
else
{
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
+ fprint_symbol (stream, TYPE_FIELD_NAME (type, i));
fputs_filtered (" = ", stream);
}
if (TYPE_FIELD_PACKED (type, i))
{
- LONGEST val;
- char *valp = (char *) & val;
+ value v;
- val = unpack_field_as_long (type, valaddr, i);
+ /* Bitfields require special handling, especially due to byte
+ order problems. */
+ v = value_from_longest (TYPE_FIELD_TYPE (type, i),
+ unpack_field_as_long (type, valaddr, i));
- /* Since we have moved the bitfield into a long,
- if it is declared with a smaller type, we need to
- offset its address *in gdb* to match the type we
- are passing to val_print. */
-#if HOST_BYTE_ORDER == BIG_ENDIAN
- valp += sizeof val - TYPE_LENGTH (TYPE_FIELD_TYPE (type, i));
-#endif
- val_print (TYPE_FIELD_TYPE (type, i), valp, 0,
+ val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
stream, format, 0, recurse + 1, pretty);
}
else
struct type *type;
char *valaddr;
FILE *stream;
- char format;
+ int format;
int recurse;
enum val_prettyprint pretty;
struct type **dont_print;
for (i = 0; i < n_baseclasses; i++)
{
char *baddr;
+ int err;
if (BASETYPE_VIA_VIRTUAL (type, i))
{
obstack_ptr_grow (&dont_print_obstack, TYPE_BASECLASS (type, i));
}
- baddr = baseclass_addr (type, i, valaddr, 0);
- if (baddr == 0)
+ baddr = baseclass_addr (type, i, valaddr, 0, &err);
+ if (err == 0 && baddr == 0)
error ("could not find virtual baseclass `%s'\n",
type_name_no_tag (TYPE_BASECLASS (type, i)));
- fprintf_filtered (stream, "\n");
if (pretty)
- print_spaces_filtered (2 + 2 * recurse, stream);
+ {
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 * recurse, stream);
+ }
fputs_filtered ("<", stream);
fputs_filtered (type_name_no_tag (TYPE_BASECLASS (type, i)), stream);
fputs_filtered ("> = ", stream);
- val_print_fields (TYPE_BASECLASS (type, i), baddr, stream, format,
- recurse, pretty,
- (struct type **)obstack_base (&dont_print_obstack));
+ if (err != 0)
+ fprintf_filtered (stream, "<invalid address 0x%x>", baddr);
+ else
+ val_print_fields (TYPE_BASECLASS (type, i), baddr, stream, format,
+ recurse, pretty,
+ (struct type **)obstack_base (&dont_print_obstack));
+ fputs_filtered (", ", stream);
+
flush_it:
;
}
}
}
+static void
+print_class_member (valaddr, domain, stream, prefix)
+ char *valaddr;
+ struct type *domain;
+ FILE *stream;
+ char *prefix;
+{
+
+ /* VAL is a byte offset into the structure type DOMAIN.
+ Find the name of the field for that offset and
+ print it. */
+ int extra = 0;
+ int bits = 0;
+ register unsigned int i;
+ unsigned len = TYPE_NFIELDS (domain);
+ /* @@ Make VAL into bit offset */
+ LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
+ for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
+ {
+ int bitpos = TYPE_FIELD_BITPOS (domain, i);
+ QUIT;
+ if (val == bitpos)
+ break;
+ if (val < bitpos && i != 0)
+ {
+ /* Somehow pointing into a field. */
+ i -= 1;
+ extra = (val - TYPE_FIELD_BITPOS (domain, i));
+ if (extra & 0x7)
+ bits = 1;
+ else
+ extra >>= 3;
+ break;
+ }
+ }
+ if (i < len)
+ {
+ char *name;
+ fprintf_filtered (stream, prefix);
+ name = type_name_no_tag (domain);
+ if (name)
+ fputs_filtered (name, stream);
+ else
+ type_print_base (domain, stream, 0, 0);
+ fprintf_filtered (stream, "::");
+ fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
+ if (extra)
+ fprintf_filtered (stream, " + %d bytes", extra);
+ if (bits)
+ fprintf_filtered (stream, " (offset in bits)");
+ }
+ else
+ fprintf_filtered (stream, "%d", val >> 3);
+}
+
/* Print data of type TYPE located at VALADDR (within GDB),
which came from the inferior at address ADDRESS,
onto stdio stream STREAM according to FORMAT
The PRETTY parameter controls prettyprinting. */
int
-val_print (type, valaddr, address, stream, format,
- deref_ref, recurse, pretty)
+val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
struct type *type;
char *valaddr;
CORE_ADDR address;
FILE *stream;
- char format;
+ int format;
int deref_ref;
int recurse;
enum val_prettyprint pretty;
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- if (TYPE_LENGTH (type) >= 0
+ if (TYPE_LENGTH (type) > 0
&& TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
elttype = TYPE_TARGET_TYPE (type);
{
unsigned int things_printed = 0;
- for (i = 0; i < len && things_printed < print_max; i++)
+ /* If this is a virtual function table, print the 0th
+ entry specially, and the rest of the members normally. */
+ if (is_vtbl_ptr_type (elttype))
+ {
+ fprintf_filtered (stream, "%d vtable entries", len-1);
+ i = 1;
+ }
+ else
+ i = 0;
+
+ for (; i < len && things_printed < print_max; i++)
{
/* Position of the array element we are examining to see
whether it is repeated. */
rep1 = i + 1;
reps = 1;
while (rep1 < len
- && !bcmp (valaddr + i * eltlen,
- valaddr + rep1 * eltlen, eltlen))
+ && !memcmp (valaddr + i * eltlen,
+ valaddr + rep1 * eltlen, eltlen))
{
++reps;
++rep1;
struct fn_field *f;
int j, len2;
char *kind = "";
+ CORE_ADDR addr;
- val = unpack_long (builtin_type_int, valaddr);
- if (val < 128)
+ addr = unpack_pointer (lookup_pointer_type (builtin_type_void),
+ valaddr);
+ if (addr < 128) /* FIXME! What is this 128? */
{
len = TYPE_NFN_FIELDS (domain);
for (i = 0; i < len; i++)
for (j = 0; j < len2; j++)
{
QUIT;
- if (TYPE_FN_FIELD_VOFFSET (f, j) == val)
+ if (TYPE_FN_FIELD_VOFFSET (f, j) == addr)
{
kind = "virtual";
goto common;
}
else
{
- struct symbol *sym = find_pc_function ((CORE_ADDR) val);
+ struct symbol *sym = find_pc_function (addr);
if (sym == 0)
error ("invalid pointer to member function");
len = TYPE_NFN_FIELDS (domain);
}
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
- fprintf_filtered (stream, ") %d", (int) val >> 3);
+ fprintf_filtered (stream, ") %d", (int) addr >> 3);
}
else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
{
- struct type *domain = TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type));
-
- /* VAL is a byte offset into the structure type DOMAIN.
- Find the name of the field for that offset and
- print it. */
- int extra = 0;
- int bits = 0;
- len = TYPE_NFIELDS (domain);
- /* @@ Make VAL into bit offset */
- val = unpack_long (builtin_type_int, valaddr) << 3;
- for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
- {
- int bitpos = TYPE_FIELD_BITPOS (domain, i);
- QUIT;
- if (val == bitpos)
- break;
- if (val < bitpos && i != 0)
- {
- /* Somehow pointing into a field. */
- i -= 1;
- extra = (val - TYPE_FIELD_BITPOS (domain, i));
- if (extra & 0x3)
- bits = 1;
- else
- extra >>= 3;
- break;
- }
- }
- if (i < len)
- {
- fprintf_filtered (stream, "&");
- type_print_base (domain, stream, 0, 0);
- fprintf_filtered (stream, "::");
- fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
- if (extra)
- fprintf_filtered (stream, " + %d bytes", extra);
- if (bits)
- fprintf_filtered (stream, " (offset in bits)");
- break;
- }
- fprintf_filtered (stream, "%d", val >> 3);
+ print_class_member (valaddr,
+ TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
+ stream, "&");
}
else
{
- CORE_ADDR addr = (CORE_ADDR) unpack_long (type, valaddr);
+ CORE_ADDR addr = unpack_pointer (type, valaddr);
elttype = TYPE_TARGET_TYPE (type);
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
slower if print_max is set high, e.g. if you set
print_max to 1000, not only will it take a long
time to fetch short strings, but if you are near
- the end of the address space, it might not work.
- FIXME. */
+ the end of the address space, it might not work. */
QUIT;
errcode = target_read_memory (addr, string, print_max);
+ if (errcode != 0)
+ {
+ /* Try reading just one character. If that succeeds,
+ assume we hit the end of the address space, but
+ the initial part of the string is probably safe. */
+ char x[1];
+ errcode = target_read_memory (addr, x, 1);
+ }
if (errcode != 0)
force_ellipses = 0;
else
}
else
{
- if (errcode >= sys_nerr || errcode < 0)
- error ("Error reading memory address 0x%x: unknown error (%d).",
- addr + i, errcode);
- else
- error ("Error reading memory address 0x%x: %s.",
- addr + i, sys_errlist[errcode]);
+ error ("Error reading memory address 0x%x: %s.",
+ addr + i, safe_strerror (errcode));
}
}
else /* print vtbl's nicely */
if (is_vtbl_member(type))
{
- CORE_ADDR vt_address = (CORE_ADDR) unpack_long (type, valaddr);
+ CORE_ADDR vt_address = unpack_pointer (type, valaddr);
- int vt_index = find_pc_misc_function (vt_address);
- if (vt_index >= 0
- && vt_address == misc_function_vector[vt_index].address)
+ struct minimal_symbol *msymbol =
+ lookup_minimal_symbol_by_pc (vt_address);
+ if ((msymbol != NULL) && (vt_address == msymbol -> address))
{
fputs_filtered (" <", stream);
- fputs_demangled (misc_function_vector[vt_index].name,
- stream, 1);
+ fputs_demangled (msymbol -> name, stream,
+ DMGL_ANSI | DMGL_PARAMS);
fputs_filtered (">", stream);
}
if (vtblprint)
{
- value val;
+ value vt_val;
- val = value_at (TYPE_TARGET_TYPE (type), vt_address);
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
- VALUE_ADDRESS (val), stream, format,
+ vt_val = value_at (TYPE_TARGET_TYPE (type), vt_address);
+ val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val),
+ VALUE_ADDRESS (vt_val), stream, format,
deref_ref, recurse + 1, pretty);
if (pretty)
{
break;
case TYPE_CODE_REF:
+ if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
+ {
+ print_class_member (valaddr,
+ TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
+ stream, "");
+ break;
+ }
if (addressprint)
{
fprintf_filtered (stream, "@0x%lx",
{
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
{
- value val = value_at (TYPE_TARGET_TYPE (type),
- (CORE_ADDR) unpack_long (builtin_type_int,
- valaddr));
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
- VALUE_ADDRESS (val), stream, format,
+ value deref_val =
+ value_at
+ (TYPE_TARGET_TYPE (type),
+ unpack_pointer (lookup_pointer_type (builtin_type_void),
+ valaddr));
+ val_print (VALUE_TYPE (deref_val), VALUE_CONTENTS (deref_val),
+ VALUE_ADDRESS (deref_val), stream, format,
deref_ref, recurse + 1, pretty);
}
else
if (i < len)
fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
else
- fprintf_filtered (stream, "%d", (int) val);
+#ifdef LONG_LONG
+ fprintf_filtered (stream, "%lld", val);
+#else
+ fprintf_filtered (stream, "%ld", val);
+#endif
break;
case TYPE_CODE_FUNC:
print_scalar_formatted (valaddr, type, format, 0, stream);
break;
}
+ /* FIXME, we should consider, at least for ANSI C language, eliminating
+ the distinction made between FUNCs and POINTERs to FUNCs. */
fprintf_filtered (stream, "{");
type_print (type, "", stream, -1);
fprintf_filtered (stream, "} ");
- if (addressprint)
- fprintf_filtered (stream, "0x%x", address);
+ /* Try to print what function it points to, and its address. */
+ print_address_demangle (address, stream, demangle);
break;
case TYPE_CODE_INT:
char *p;
/* Pointer to first (i.e. lowest address) nonzero character. */
char *first_addr;
- unsigned len = TYPE_LENGTH (type);
+ len = TYPE_LENGTH (type);
#if TARGET_BYTE_ORDER == BIG_ENDIAN
for (p = valaddr;
fprintf_filtered (stream, "?");
break;
+ case TYPE_CODE_RANGE:
+ /* FIXME, we should not ever have to print one of these yet. */
+ fprintf_filtered (stream, "<range type>");
+ break;
+
default:
error ("Invalid type code in symbol table.");
}
return 0;
}
\f
+/* Print a description of a type in the format of a
+ typedef for the current language.
+ NEW is the new name for a type TYPE. */
+void
+typedef_print (type, new, stream)
+ struct type *type;
+ struct symbol *new;
+ FILE *stream;
+{
+ switch (current_language->la_language)
+ {
+#ifdef _LANG_c
+ case language_c:
+ case language_cplus:
+ fprintf_filtered(stream, "typedef ");
+ type_print(type,"",stream,0);
+ if(TYPE_NAME ((SYMBOL_TYPE (new))) == 0
+ || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (new))),
+ SYMBOL_NAME (new)))
+ fprintf_filtered(stream, " %s", SYMBOL_NAME(new));
+ break;
+#endif
+#ifdef _LANG_m2
+ case language_m2:
+ fprintf_filtered(stream, "TYPE ");
+ if(!TYPE_NAME(SYMBOL_TYPE(new)) ||
+ strcmp (TYPE_NAME(SYMBOL_TYPE(new)),
+ SYMBOL_NAME(new)))
+ fprintf_filtered(stream, "%s = ", SYMBOL_NAME(new));
+ else
+ fprintf_filtered(stream, "<builtin> = ");
+ type_print(type,"",stream,0);
+ break;
+#endif
+ default:
+ error("Language not supported.");
+ }
+ fprintf_filtered(stream, ";\n");
+}
+
+
/* Print a description of a type TYPE
in the form of a declaration of a variable named VARSTRING.
(VARSTRING is demangled if necessary.)
int level;
{
register enum type_code code;
+ char *demangled = NULL;
+ int demangled_args;
+
type_print_base (type, stream, show, level);
code = TYPE_CODE (type);
if ((varstring && *varstring)
|| code == TYPE_CODE_REF)))
fprintf_filtered (stream, " ");
type_print_varspec_prefix (type, stream, show, 0);
- fputs_demangled (varstring, stream, -1); /* Print demangled name
- without arguments */
- type_print_varspec_suffix (type, stream, show, 0);
+
+ /* See if the name has a C++ demangled equivalent, and if so, print that
+ instead. */
+
+ if (demangle)
+ {
+ demangled = cplus_demangle (varstring, DMGL_ANSI | DMGL_PARAMS);
+ }
+ fputs_filtered ((demangled != NULL) ? demangled : varstring, stream);
+
+ /* For demangled function names, we have the arglist as part of the name,
+ so don't print an additional pair of ()'s */
+
+ demangled_args = (demangled != NULL) && (code == TYPE_CODE_FUNC);
+ type_print_varspec_suffix (type, stream, show, 0, demangled_args);
+
+ if (demangled)
+ {
+ free (demangled);
+ }
}
/* Print the method arguments ARGS to the file STREAM. */
{
int i;
- fputs_filtered (" ", stream);
- fputs_demangled (prefix, stream, 1);
- fputs_demangled (varstring, stream, 1);
+ fputs_demangled (prefix, stream, DMGL_ANSI | DMGL_PARAMS);
+ fputs_demangled (varstring, stream, DMGL_ANSI | DMGL_PARAMS);
fputs_filtered (" (", stream);
if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
{
fprintf_filtered (stream, ")");
}
-/* If TYPE is a derived type, then print out derivation
- information. Print out all layers of the type heirarchy
- until we encounter one with multiple inheritance.
- At that point, print out that ply, and return. */
+/* If TYPE is a derived type, then print out derivation information.
+ Print only the actual base classes of this type, not the base classes
+ of the base classes. I.E. for the derivation hierarchy:
+
+ class A { int a; };
+ class B : public A {int b; };
+ class C : public B {int c; };
+
+ Print the type of class C as:
+
+ class C : public B {
+ int c;
+ }
+
+ Not as the following (like gdb used to), which is not legal C++ syntax for
+ derived types and may be confused with the multiple inheritance form:
+
+ class C : public B : public A {
+ int c;
+ }
+
+ In general, gdb should try to print the types as closely as possible to
+ the form that they appear in the source code. */
+
static void
type_print_derivation_info (stream, type)
FILE *stream;
struct type *type;
{
char *name;
- int i, n_baseclasses = TYPE_N_BASECLASSES (type);
- struct type *basetype = 0;
+ int i;
- while (type && n_baseclasses > 0)
+ for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- /* Not actually sure about this one -- Bryan. */
- check_stub_type (type);
-
- fprintf_filtered (stream, ": ");
- for (i = 0; ;)
- {
- basetype = TYPE_BASECLASS (type, i);
- if (name = type_name_no_tag (basetype))
- {
- fprintf_filtered (stream, "%s%s ",
- BASETYPE_VIA_PUBLIC(type, i) ? "public" : "private",
- BASETYPE_VIA_VIRTUAL(type, i) ? " virtual" : "");
- fputs_filtered (name, stream);
- }
- i++;
- if (i >= n_baseclasses)
- break;
- fprintf_filtered (stream, ", ");
- }
-
- fprintf_filtered (stream, " ");
- if (n_baseclasses != 1)
- break;
- n_baseclasses = TYPE_N_BASECLASSES (basetype);
- type = basetype;
+ fputs_filtered (i == 0 ? ": " : ", ", stream);
+ fprintf_filtered (stream, "%s%s ",
+ BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private",
+ BASETYPE_VIA_VIRTUAL(type, i) ? " virtual" : "");
+ name = type_name_no_tag (TYPE_BASECLASS (type, i));
+ fprintf_filtered (stream, "%s", name ? name : "(null)");
+ }
+ if (i > 0)
+ {
+ fputs_filtered (" ", stream);
}
}
int show;
int passed_a_ptr;
{
+ char *name;
if (type == 0)
return;
type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
0);
fprintf_filtered (stream, " ");
- type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0,
- passed_a_ptr);
+ name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
+ if (name)
+ fputs_filtered (name, stream);
+ else
+ type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
fprintf_filtered (stream, "::");
break;
fprintf (stream, "(");
type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
0);
- fprintf_filtered (stream, " ");
- type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0,
- passed_a_ptr);
- fprintf_filtered (stream, "::");
+ if (passed_a_ptr)
+ {
+ fprintf_filtered (stream, " ");
+ type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0,
+ passed_a_ptr);
+ fprintf_filtered (stream, "::");
+ }
break;
case TYPE_CODE_REF:
0);
if (passed_a_ptr)
fprintf_filtered (stream, "(");
+ break;
case TYPE_CODE_UNDEF:
case TYPE_CODE_STRUCT:
case TYPE_CODE_FLT:
case TYPE_CODE_VOID:
case TYPE_CODE_ERROR:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_SET:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_PASCAL_ARRAY:
/* These types need no prefix. They are listed here so that
gcc -Wall will reveal any types that haven't been handled. */
break;
}
}
+static void
+type_print_args (type, stream)
+ struct type *type;
+ FILE *stream;
+{
+ int i;
+ struct type **args;
+
+ fprintf_filtered (stream, "(");
+ args = TYPE_ARG_TYPES (type);
+ if (args != NULL)
+ {
+ if (args[1] == NULL)
+ {
+ fprintf_filtered (stream, "...");
+ }
+ else
+ {
+ for (i = 1;
+ args[i] != NULL && args[i]->code != TYPE_CODE_VOID;
+ i++)
+ {
+ type_print_1 (args[i], "", stream, -1, 0);
+ if (args[i+1] == NULL)
+ {
+ fprintf_filtered (stream, "...");
+ }
+ else if (args[i+1]->code != TYPE_CODE_VOID)
+ {
+ fprintf_filtered (stream, ",");
+ wrap_here (" ");
+ }
+ }
+ }
+ }
+ fprintf_filtered (stream, ")");
+}
+
/* Print any array sizes, function arguments or close parentheses
needed after the variable name (to describe its type).
Args work like type_print_varspec_prefix. */
static void
-type_print_varspec_suffix (type, stream, show, passed_a_ptr)
+type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args)
struct type *type;
FILE *stream;
int show;
int passed_a_ptr;
+ int demangled_args;
{
if (type == 0)
return;
fprintf_filtered (stream, ")");
fprintf_filtered (stream, "[");
- if (TYPE_LENGTH (type) >= 0
+ if (TYPE_LENGTH (type) > 0
&& TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
fprintf_filtered (stream, "%d",
(TYPE_LENGTH (type)
fprintf_filtered (stream, "]");
type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
- 0);
+ 0, 0);
break;
case TYPE_CODE_MEMBER:
if (passed_a_ptr)
fprintf_filtered (stream, ")");
- type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+ type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
break;
case TYPE_CODE_METHOD:
if (passed_a_ptr)
fprintf_filtered (stream, ")");
- type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+ type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
if (passed_a_ptr)
{
- int i;
- struct type **args = TYPE_ARG_TYPES (type);
-
- fprintf_filtered (stream, "(");
- if (args[1] == 0)
- fprintf_filtered (stream, "...");
- else for (i = 1; args[i] != 0 && args[i]->code != TYPE_CODE_VOID; i++)
- {
- type_print_1 (args[i], "", stream, -1, 0);
- if (args[i+1] == 0)
- fprintf_filtered (stream, "...");
- else if (args[i+1]->code != TYPE_CODE_VOID)
- fprintf_filtered (stream, ",");
- }
- fprintf_filtered (stream, ")");
+ type_print_args (type, stream);
}
break;
case TYPE_CODE_PTR:
case TYPE_CODE_REF:
- type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1);
+ type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
break;
case TYPE_CODE_FUNC:
type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
- passed_a_ptr);
+ passed_a_ptr, 0);
if (passed_a_ptr)
fprintf_filtered (stream, ")");
- fprintf_filtered (stream, "()");
+ if (!demangled_args)
+ fprintf_filtered (stream, "()");
break;
case TYPE_CODE_UNDEF:
case TYPE_CODE_FLT:
case TYPE_CODE_VOID:
case TYPE_CODE_ERROR:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_SET:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_PASCAL_ARRAY:
/* These types do not need a suffix. They are listed so that
gcc -Wall will report types that may not have been considered. */
break;
register int i;
register int len;
register int lastval;
-
+ char *mangled_name;
+ char *demangled_name;
+ enum {s_none, s_public, s_private, s_protected} section_type;
QUIT;
- if (type == 0)
+ wrap_here (" ");
+ if (type == NULL)
{
- fprintf_filtered (stream, "type unknown");
+ fputs_filtered ("<type unknown>", stream);
return;
}
- if (TYPE_NAME (type) && show <= 0)
+ /* When SHOW is zero or less, and there is a valid type name, then always
+ just print the type name directly from the type. */
+
+ if ((show <= 0) && (TYPE_NAME (type) != NULL))
{
fputs_filtered (TYPE_NAME (type), stream);
return;
break;
case TYPE_CODE_STRUCT:
- fprintf_filtered (stream, "struct ");
+ fprintf_filtered (stream,
+ HAVE_CPLUS_STRUCT (type) ? "class " : "struct ");
goto struct_union;
case TYPE_CODE_UNION:
{
fputs_filtered (name, stream);
fputs_filtered (" ", stream);
+ wrap_here (" ");
}
if (show < 0)
fprintf_filtered (stream, "{...}");
type_print_derivation_info (stream, type);
- fprintf_filtered (stream, "{");
- len = TYPE_NFIELDS (type);
- if (len)
- fprintf_filtered (stream, "\n");
- else
+ fprintf_filtered (stream, "{\n");
+ if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
{
if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
- fprintf_filtered (stream, "<incomplete type>\n");
+ fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
else
- fprintf_filtered (stream, "<no data fields>\n");
+ fprintfi_filtered (level + 4, stream, "<no data fields>\n");
}
+ /* Start off with no specific section type, so we can print
+ one for the first field we find, and use that section type
+ thereafter until we find another type. */
+
+ section_type = s_none;
+
/* If there is a base class for this type,
do not print the field that it occupies. */
+
+ len = TYPE_NFIELDS (type);
for (i = TYPE_N_BASECLASSES (type); i < len; i++)
{
QUIT;
!strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5))
continue;
+ /* If this is a C++ class we can print the various C++ section
+ labels. */
+
+ if (HAVE_CPLUS_STRUCT (type))
+ {
+ if (TYPE_FIELD_PROTECTED (type, i))
+ {
+ if (section_type != s_protected)
+ {
+ section_type = s_protected;
+ fprintfi_filtered (level + 2, stream,
+ "protected:\n");
+ }
+ }
+ else if (TYPE_FIELD_PRIVATE (type, i))
+ {
+ if (section_type != s_private)
+ {
+ section_type = s_private;
+ fprintfi_filtered (level + 2, stream, "private:\n");
+ }
+ }
+ else
+ {
+ if (section_type != s_public)
+ {
+ section_type = s_public;
+ fprintfi_filtered (level + 2, stream, "public:\n");
+ }
+ }
+ }
+
print_spaces_filtered (level + 4, stream);
if (TYPE_FIELD_STATIC (type, i))
{
/* C++: print out the methods */
len = TYPE_NFN_FIELDS (type);
- if (len) fprintf_filtered (stream, "\n");
for (i = 0; i < len; i++)
{
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
-
+ char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
+ int is_constructor = name && strcmp(method_name, name) == 0;
for (j = 0; j < len2; j++)
{
QUIT;
+ if (TYPE_FN_FIELD_PROTECTED (f, j))
+ {
+ if (section_type != s_protected)
+ {
+ section_type = s_protected;
+ fprintfi_filtered (level + 2, stream,
+ "protected:\n");
+ }
+ }
+ else if (TYPE_FN_FIELD_PRIVATE (f, j))
+ {
+ if (section_type != s_private)
+ {
+ section_type = s_private;
+ fprintfi_filtered (level + 2, stream, "private:\n");
+ }
+ }
+ else
+ {
+ if (section_type != s_public)
+ {
+ section_type = s_public;
+ fprintfi_filtered (level + 2, stream, "public:\n");
+ }
+ }
+
print_spaces_filtered (level + 4, stream);
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
fprintf_filtered (stream, "virtual ");
else if (TYPE_FN_FIELD_STATIC_P (f, j))
fprintf_filtered (stream, "static ");
- type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)), "", stream, 0);
- if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f, j)) & TYPE_FLAG_STUB)
+ if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
+ {
+ /* Keep GDB from crashing here. */
+ fprintf (stream, "<undefined type> %s;\n",
+ TYPE_FN_FIELD_PHYSNAME (f, j));
+ break;
+ }
+ else if (!is_constructor)
+ {
+ type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
+ "", stream, 0);
+ fputs_filtered (" ", stream);
+ }
+ if (TYPE_FN_FIELD_STUB (f, j))
{
/* Build something we can demangle. */
- char *strchr (), *gdb_mangle_typename ();
- char *inner_name = gdb_mangle_typename (type);
- char *mangled_name
- = (char *)xmalloc (strlen (TYPE_FN_FIELDLIST_NAME (type, i))
- + strlen (inner_name)
- + strlen (TYPE_FN_FIELD_PHYSNAME (f, j))
- + 1);
- char *demangled_name, *cplus_demangle ();
- strcpy (mangled_name, TYPE_FN_FIELDLIST_NAME (type, i));
- strcat (mangled_name, inner_name);
- strcat (mangled_name, TYPE_FN_FIELD_PHYSNAME (f, j));
- demangled_name = cplus_demangle (mangled_name, 1);
- if (demangled_name == 0)
- fprintf_filtered (stream, " <badly mangled name %s>",
+ mangled_name = gdb_mangle_name (type, i, j);
+ demangled_name =
+ cplus_demangle (mangled_name,
+ DMGL_ANSI | DMGL_PARAMS);
+ if (demangled_name == NULL)
+ fprintf_filtered (stream, "<badly mangled name %s>",
mangled_name);
else
{
- fprintf_filtered (stream, " %s",
+ fprintf_filtered (stream, "%s",
strchr (demangled_name, ':') + 2);
free (demangled_name);
}
&& TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
type_print_method_args
(TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
- TYPE_FN_FIELDLIST_NAME (type, i), 0, stream);
+ method_name, 0, stream);
else
type_print_method_args
(TYPE_FN_FIELD_ARGS (f, j), "",
- TYPE_FN_FIELDLIST_NAME (type, i),
+ method_name,
TYPE_FN_FIELD_STATIC_P (f, j), stream);
fprintf_filtered (stream, ";\n");
}
}
- print_spaces_filtered (level, stream);
- fprintf_filtered (stream, "}");
+ fprintfi_filtered (level, stream, "}");
}
break;
fputs_filtered (name, stream);
fputs_filtered (" ", stream);
}
+ wrap_here (" ");
if (show < 0)
fprintf_filtered (stream, "{...}");
else
{
QUIT;
if (i) fprintf_filtered (stream, ", ");
+ wrap_here (" ");
fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
if (lastval != TYPE_FIELD_BITPOS (type, i))
{
}
break;
- case TYPE_CODE_INT:
- if (TYPE_LENGTH (type) > sizeof (LONGEST))
- {
- fprintf_filtered (stream, "<%d bit integer>",
- TYPE_LENGTH (type) * TARGET_CHAR_BIT);
- }
- else
- {
- if (TYPE_UNSIGNED (type))
- name = unsigned_type_table[TYPE_LENGTH (type)];
- else
- name = signed_type_table[TYPE_LENGTH (type)];
- }
- fputs_filtered (name, stream);
- break;
-
- case TYPE_CODE_FLT:
- name = float_type_table[TYPE_LENGTH (type)];
- fputs_filtered (name, stream);
- break;
-
case TYPE_CODE_VOID:
fprintf_filtered (stream, "void");
break;
- case 0:
- fprintf_filtered (stream, "struct unknown");
+ case TYPE_CODE_UNDEF:
+ fprintf_filtered (stream, "struct <unknown>");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, "<unknown type>");
break;
+ case TYPE_CODE_RANGE:
+ /* This should not occur */
+ fprintf_filtered (stream, "<range type>");
+ break;
+
default:
- error ("Invalid type code in symbol table.");
+ /* Handle types not explicitly handled by the other cases,
+ such as fundamental types. For these, just print whatever
+ the type name is, as recorded in the type itself. If there
+ is no type name, then complain. */
+ if (TYPE_NAME (type) != NULL)
+ {
+ fputs_filtered (TYPE_NAME (type), stream);
+ }
+ else
+ {
+ error ("Invalid type code (%d) in symbol table.", TYPE_CODE (type));
+ }
+ break;
}
}
\f
+#if 0
/* Validate an input or output radix setting, and make sure the user
knows what they really did here. Radix setting is confusing, e.g.
setting the input radix to "10" never changes it! */
+/* ARGSUSED */
static void
set_input_radix (args, from_tty, c)
char *args;
printf_filtered ("Input radix set to decimal %d, hex %x, octal %o\n",
radix, radix, radix);
}
+#endif
+/* ARGSUSED */
static void
set_output_radix (args, from_tty, c)
char *args;
set_output_radix (arg, 0, c);
}
\f
+/*ARGSUSED*/
+static void
+set_print (arg, from_tty)
+ char *arg;
+ int from_tty;
+{
+ printf (
+"\"set print\" must be followed by the name of a print subcommand.\n");
+ help_list (setprintlist, "set print ", -1, stdout);
+}
+
+/*ARGSUSED*/
+static void
+show_print (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ cmd_show_list (showprintlist, from_tty, "");
+}
+\f
void
_initialize_valprint ()
{
struct cmd_list_element *c;
+ add_prefix_cmd ("print", no_class, set_print,
+ "Generic command for setting how things print.",
+ &setprintlist, "set print ", 0, &setlist);
+ add_alias_cmd ("p", "print", no_class, 1, &setlist);
+ add_alias_cmd ("pr", "print", no_class, 1, &setlist); /* prefer set print
+ to set prompt */
+ add_prefix_cmd ("print", no_class, show_print,
+ "Generic command for showing print settings.",
+ &showprintlist, "show print ", 0, &showlist);
+ add_alias_cmd ("p", "print", no_class, 1, &showlist);
+ add_alias_cmd ("pr", "print", no_class, 1, &showlist);
+
add_show_from_set
- (add_set_cmd ("array-max", class_vars, var_uinteger, (char *)&print_max,
+ (add_set_cmd ("elements", no_class, var_uinteger, (char *)&print_max,
"Set limit on string chars or array elements to print.\n\
-\"set array-max 0\" causes there to be no limit.",
- &setlist),
- &showlist);
+\"set print elements 0\" causes there to be no limit.",
+ &setprintlist),
+ &showprintlist);
add_show_from_set
- (add_set_cmd ("prettyprint", class_support, var_boolean, (char *)&prettyprint,
+ (add_set_cmd ("pretty", class_support, var_boolean, (char *)&prettyprint,
"Set prettyprinting of structures.",
- &setlist),
- &showlist);
-
- add_alias_cmd ("pp", "prettyprint", class_support, 1, &setlist);
+ &setprintlist),
+ &showprintlist);
add_show_from_set
- (add_set_cmd ("unionprint", class_support, var_boolean, (char *)&unionprint,
+ (add_set_cmd ("union", class_support, var_boolean, (char *)&unionprint,
"Set printing of unions interior to structures.",
- &setlist),
- &showlist);
+ &setprintlist),
+ &showprintlist);
add_show_from_set
- (add_set_cmd ("vtblprint", class_support, var_boolean, (char *)&vtblprint,
+ (add_set_cmd ("vtbl", class_support, var_boolean, (char *)&vtblprint,
"Set printing of C++ virtual function tables.",
- &setlist),
- &showlist);
+ &setprintlist),
+ &showprintlist);
add_show_from_set
- (add_set_cmd ("arrayprint", class_support, var_boolean, (char *)&arrayprint,
+ (add_set_cmd ("array", class_support, var_boolean, (char *)&arrayprint,
"Set prettyprinting of arrays.",
- &setlist),
- &showlist);
+ &setprintlist),
+ &showprintlist);
+
+ add_show_from_set
+ (add_set_cmd ("object", class_support, var_boolean, (char *)&objectprint,
+ "Set printing of object's derived type based on vtable info.",
+ &setprintlist),
+ &showprintlist);
add_show_from_set
- (add_set_cmd ("addressprint", class_support, var_boolean, (char *)&addressprint,
+ (add_set_cmd ("address", class_support, var_boolean, (char *)&addressprint,
"Set printing of addresses.",
- &setlist),
- &showlist);
+ &setprintlist),
+ &showprintlist);
#if 0
/* The "show radix" cmd isn't good enough to show two separate values.
"Set default input and output number radix.",
&setlist);
add_show_from_set (c, &showlist);
- c->function = set_radix;
+ c->function.sfunc = set_radix;
/* Give people the defaults which they are used to. */
prettyprint = 0;
vtblprint = 0;
arrayprint = 0;
addressprint = 1;
+ objectprint = 0;
print_max = 200;
- unsigned_type_table
- = (char **) xmalloc ((1 + sizeof (unsigned LONGEST)) * sizeof (char *));
- bzero (unsigned_type_table, (1 + sizeof (unsigned LONGEST)));
- unsigned_type_table[sizeof (unsigned char)] = "unsigned char";
- unsigned_type_table[sizeof (unsigned short)] = "unsigned short";
- unsigned_type_table[sizeof (unsigned long)] = "unsigned long";
- unsigned_type_table[sizeof (unsigned int)] = "unsigned int";
-#ifdef LONG_LONG
- unsigned_type_table[sizeof (unsigned long long)] = "unsigned long long";
-#endif
-
- signed_type_table
- = (char **) xmalloc ((1 + sizeof (LONGEST)) * sizeof (char *));
- bzero (signed_type_table, (1 + sizeof (LONGEST)));
- signed_type_table[sizeof (char)] = "char";
- signed_type_table[sizeof (short)] = "short";
- signed_type_table[sizeof (long)] = "long";
- signed_type_table[sizeof (int)] = "int";
-#ifdef LONG_LONG
- signed_type_table[sizeof (long long)] = "long long";
-#endif
-
- float_type_table
- = (char **) xmalloc ((1 + sizeof (double)) * sizeof (char *));
- bzero (float_type_table, (1 + sizeof (double)));
- float_type_table[sizeof (float)] = "float";
- float_type_table[sizeof (double)] = "double";
obstack_begin (&dont_print_obstack, 32 * sizeof (struct type *));
}