X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fp-valprint.c;h=72dc6fd40d41576234ffc90f989d88df3d4bcb46;hb=35fd2deb6916e972248d52b1bc1d584fa9059f8f;hp=0049233c22f67f6697c9893ba9ad12bee4994cd9;hpb=9fb92a5a5b003e2741171194dc5ae5eb3ba5f4aa;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index 0049233c22..72dc6fd40d 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -1,13 +1,12 @@
/* Support for printing Pascal values for GDB, the GNU debugger.
- Copyright (C) 2000, 2001, 2003, 2005, 2006
- Free Software Foundation, Inc.
+ Copyright (C) 2000-2016 Free Software Foundation, Inc.
This file is part of GDB.
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 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -16,9 +15,7 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see . */
/* This file is derived from c-valprint.c */
@@ -40,74 +37,83 @@
#include "p-lang.h"
#include "cp-abi.h"
#include "cp-support.h"
+#include "objfiles.h"
+/* Decorations for Pascal. */
+static const struct generic_val_print_decorations p_decorations =
+{
+ "",
+ " + ",
+ " * I",
+ "true",
+ "false",
+ "void"
+};
-/* 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 (a letter or 0 for natural format). The data at VALADDR is in
- target byte order.
-
- If the data are a string pointer, returns the number of string characters
- printed.
-
- If DEREF_REF is nonzero, then dereference references, otherwise just print
- them like pointers.
-
- The PRETTY parameter controls prettyprinting. */
-
+/* See val_print for a description of the various parameters of this
+ function; they are identical. */
-int
+void
pascal_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
- struct ui_file *stream, int format, int deref_ref,
- int recurse, enum val_prettyprint pretty)
+ struct ui_file *stream, int recurse,
+ const struct value *original_value,
+ const struct value_print_options *options)
{
+ struct gdbarch *gdbarch = get_type_arch (type);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned int i = 0; /* Number of characters printed */
unsigned len;
+ LONGEST low_bound, high_bound;
struct type *elttype;
unsigned eltlen;
int length_pos, length_size, string_pos;
- int char_size;
- LONGEST val;
+ struct type *char_type;
CORE_ADDR addr;
+ int want_space = 0;
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
+ if (get_array_bounds (type, &low_bound, &high_bound))
{
+ len = high_bound - low_bound + 1;
elttype = check_typedef (TYPE_TARGET_TYPE (type));
eltlen = TYPE_LENGTH (elttype);
- len = TYPE_LENGTH (type) / eltlen;
- if (prettyprint_arrays)
+ if (options->prettyformat_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
- /* For an array of chars, print with string syntax. */
- if (eltlen == 1 &&
- ((TYPE_CODE (elttype) == TYPE_CODE_INT)
- || ((current_language->la_language == language_m2)
- && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
- && (format == 0 || format == 's'))
+ /* If 's' format is used, try to print out as string.
+ If no format is given, print as string if element type
+ is of TYPE_CODE_CHAR and element size is 1,2 or 4. */
+ if (options->format == 's'
+ || ((eltlen == 1 || eltlen == 2 || eltlen == 4)
+ && TYPE_CODE (elttype) == TYPE_CODE_CHAR
+ && options->format == 0))
{
/* If requested, look for the first null char and only print
elements up to it. */
- if (stop_print_at_null)
+ if (options->stop_print_at_null)
{
unsigned int temp_len;
- /* Look for a NULL char. */
+ /* Look for a NULL char. */
for (temp_len = 0;
- (valaddr + embedded_offset)[temp_len]
- && temp_len < len && temp_len < print_max;
+ extract_unsigned_integer (valaddr + embedded_offset +
+ temp_len * eltlen, eltlen,
+ byte_order)
+ && temp_len < len && temp_len < options->print_max;
temp_len++);
len = temp_len;
}
- LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0);
+ LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
+ valaddr + embedded_offset, len, NULL, 0,
+ options);
i = len;
}
else
@@ -124,338 +130,213 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
{
i = 0;
}
- val_print_array_elements (type, valaddr + embedded_offset, address, stream,
- format, deref_ref, recurse, pretty, i);
+ val_print_array_elements (type, valaddr, embedded_offset,
+ address, stream, recurse,
+ original_value, options, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
- addr = address;
+ addr = address + embedded_offset;
goto print_unpacked_pointer;
case TYPE_CODE_PTR:
- if (format && format != 's')
+ if (options->format && options->format != 's')
{
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
+ val_print_scalar_formatted (type, valaddr, embedded_offset,
+ original_value, options, 0, stream);
break;
}
- if (vtblprint && pascal_object_is_vtbl_ptr_type (type))
+ if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if we ARE using
- -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
+ -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
/* Extract the address, assume that it is unsigned. */
- print_address_demangle (extract_unsigned_integer (valaddr + embedded_offset, TYPE_LENGTH (type)),
- stream, demangle);
+ addr = extract_unsigned_integer (valaddr + embedded_offset,
+ TYPE_LENGTH (type), byte_order);
+ print_address_demangle (options, gdbarch, addr, stream, demangle);
break;
}
+ check_typedef (TYPE_TARGET_TYPE (type));
+
+ addr = unpack_pointer (type, valaddr + embedded_offset);
+ print_unpacked_pointer:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (elttype) == TYPE_CODE_METHOD)
- {
- pascal_object_print_class_method (valaddr + embedded_offset, type, stream);
- }
- else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
- {
- pascal_object_print_class_member (valaddr + embedded_offset,
- TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
- stream, "&");
- }
- else
- {
- addr = unpack_pointer (type, valaddr + embedded_offset);
- print_unpacked_pointer:
- elttype = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
+ if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
+ {
+ /* Try to print what function it points to. */
+ print_address_demangle (options, gdbarch, addr, stream, demangle);
+ return;
+ }
+
+ if (options->addressprint && options->format != 's')
+ {
+ fputs_filtered (paddress (gdbarch, addr), stream);
+ want_space = 1;
+ }
+
+ /* For a pointer to char or unsigned char, also print the string
+ pointed to, unless pointer is null. */
+ if (((TYPE_LENGTH (elttype) == 1
+ && (TYPE_CODE (elttype) == TYPE_CODE_INT
+ || TYPE_CODE (elttype) == TYPE_CODE_CHAR))
+ || ((TYPE_LENGTH (elttype) == 2 || TYPE_LENGTH (elttype) == 4)
+ && TYPE_CODE (elttype) == TYPE_CODE_CHAR))
+ && (options->format == 0 || options->format == 's')
+ && addr != 0)
+ {
+ if (want_space)
+ fputs_filtered (" ", stream);
+ /* No wide string yet. */
+ i = val_print_string (elttype, NULL, addr, -1, stream, options);
+ }
+ /* Also for pointers to pascal strings. */
+ /* Note: this is Free Pascal specific:
+ as GDB does not recognize stabs pascal strings
+ Pascal strings are mapped to records
+ with lowercase names PM. */
+ if (is_pascal_string_type (elttype, &length_pos, &length_size,
+ &string_pos, &char_type, NULL)
+ && addr != 0)
+ {
+ ULONGEST string_length;
+ gdb_byte *buffer;
+
+ if (want_space)
+ fputs_filtered (" ", stream);
+ buffer = (gdb_byte *) xmalloc (length_size);
+ read_memory (addr + length_pos, buffer, length_size);
+ string_length = extract_unsigned_integer (buffer, length_size,
+ byte_order);
+ xfree (buffer);
+ i = val_print_string (char_type, NULL,
+ addr + string_pos, string_length,
+ stream, options);
+ }
+ else if (pascal_object_is_vtbl_member (type))
+ {
+ /* Print vtbl's nicely. */
+ CORE_ADDR vt_address = unpack_pointer (type,
+ valaddr + embedded_offset);
+ struct bound_minimal_symbol msymbol =
+ lookup_minimal_symbol_by_pc (vt_address);
+
+ /* If 'symbol_print' is set, we did the work above. */
+ if (!options->symbol_print
+ && (msymbol.minsym != NULL)
+ && (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol)))
{
- /* Try to print what function it points to. */
- print_address_demangle (addr, stream, demangle);
- /* Return value is irrelevant except for string pointers. */
- return (0);
+ if (want_space)
+ fputs_filtered (" ", stream);
+ fputs_filtered ("<", stream);
+ fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
+ fputs_filtered (">", stream);
+ want_space = 1;
}
-
- if (addressprint && format != 's')
+ if (vt_address && options->vtblprint)
{
- deprecated_print_address_numeric (addr, 1, stream);
- }
+ struct value *vt_val;
+ struct symbol *wsym = NULL;
+ struct type *wtype;
+ struct block *block = NULL;
+ struct field_of_this_result is_this_fld;
- /* For a pointer to char or unsigned char, also print the string
- pointed to, unless pointer is null. */
- if (TYPE_LENGTH (elttype) == 1
- && TYPE_CODE (elttype) == TYPE_CODE_INT
- && (format == 0 || format == 's')
- && addr != 0)
- {
- /* no wide string yet */
- i = val_print_string (addr, -1, 1, stream);
- }
- /* also for pointers to pascal strings */
- /* Note: this is Free Pascal specific:
- as GDB does not recognize stabs pascal strings
- Pascal strings are mapped to records
- with lowercase names PM */
- if (is_pascal_string_type (elttype, &length_pos, &length_size,
- &string_pos, &char_size, NULL)
- && addr != 0)
- {
- ULONGEST string_length;
- void *buffer;
- buffer = xmalloc (length_size);
- read_memory (addr + length_pos, buffer, length_size);
- string_length = extract_unsigned_integer (buffer, length_size);
- xfree (buffer);
- i = val_print_string (addr + string_pos, string_length, char_size, stream);
- }
- else if (pascal_object_is_vtbl_member (type))
- {
- /* print vtbl's nicely */
- CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
+ if (want_space)
+ fputs_filtered (" ", stream);
- struct minimal_symbol *msymbol =
- lookup_minimal_symbol_by_pc (vt_address);
- if ((msymbol != NULL)
- && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
+ if (msymbol.minsym != NULL)
+ wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
+ block,
+ VAR_DOMAIN, &is_this_fld).symbol;
+
+ if (wsym)
{
- fputs_filtered (" <", stream);
- fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
- fputs_filtered (">", stream);
+ wtype = SYMBOL_TYPE (wsym);
}
- if (vt_address && vtblprint)
+ else
{
- struct value *vt_val;
- struct symbol *wsym = (struct symbol *) NULL;
- struct type *wtype;
- struct block *block = (struct block *) NULL;
- int is_this_fld;
-
- if (msymbol != NULL)
- wsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), block,
- VAR_DOMAIN, &is_this_fld, NULL);
-
- if (wsym)
- {
- wtype = SYMBOL_TYPE (wsym);
- }
- else
- {
- wtype = TYPE_TARGET_TYPE (type);
- }
- vt_val = value_at (wtype, vt_address);
- common_val_print (vt_val, stream, format, deref_ref,
- recurse + 1, pretty);
- if (pretty)
- {
- fprintf_filtered (stream, "\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
- }
+ wtype = TYPE_TARGET_TYPE (type);
+ }
+ vt_val = value_at (wtype, vt_address);
+ common_val_print (vt_val, stream, recurse + 1, options,
+ current_language);
+ if (options->prettyformat)
+ {
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 + 2 * recurse, stream);
}
}
-
- /* Return number of characters printed, including the terminating
- '\0' if we reached the end. val_print_string takes care including
- the terminating '\0' if necessary. */
- return i;
}
- break;
- case TYPE_CODE_MEMBER:
- error (_("not implemented: member type in pascal_val_print"));
- break;
+ return;
case TYPE_CODE_REF:
- elttype = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
- {
- pascal_object_print_class_member (valaddr + embedded_offset,
- TYPE_DOMAIN_TYPE (elttype),
- stream, "");
- break;
- }
- if (addressprint)
- {
- fprintf_filtered (stream, "@");
- /* Extract the address, assume that it is unsigned. */
- deprecated_print_address_numeric
- (extract_unsigned_integer (valaddr + embedded_offset,
- TARGET_PTR_BIT / HOST_CHAR_BIT),
- 1, stream);
- if (deref_ref)
- fputs_filtered (": ", stream);
- }
- /* De-reference the reference. */
- if (deref_ref)
- {
- if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
- {
- struct value *deref_val =
- value_at
- (TYPE_TARGET_TYPE (type),
- unpack_pointer (lookup_pointer_type (builtin_type_void),
- valaddr + embedded_offset));
- common_val_print (deref_val, stream, format, deref_ref,
- recurse + 1, pretty);
- }
- else
- fputs_filtered ("???", stream);
- }
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLAGS:
+ case TYPE_CODE_FUNC:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_INT:
+ case TYPE_CODE_FLT:
+ case TYPE_CODE_VOID:
+ case TYPE_CODE_ERROR:
+ case TYPE_CODE_UNDEF:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_CHAR:
+ generic_val_print (type, valaddr, embedded_offset, address,
+ stream, recurse, original_value, options,
+ &p_decorations);
break;
case TYPE_CODE_UNION:
- if (recurse && !unionprint)
+ if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
- if (vtblprint && pascal_object_is_vtbl_ptr_type (type))
+ if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type))
{
/* Print the unmangled name if desired. */
/* Print vtable entry - we only get here if NOT using
- -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
+ -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
/* Extract the address, assume that it is unsigned. */
print_address_demangle
- (extract_unsigned_integer (valaddr + embedded_offset + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8,
- TYPE_LENGTH (TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET))),
+ (options, gdbarch,
+ extract_unsigned_integer (valaddr + embedded_offset
+ + TYPE_FIELD_BITPOS (type,
+ VTBL_FNADDR_OFFSET) / 8,
+ TYPE_LENGTH (TYPE_FIELD_TYPE (type,
+ VTBL_FNADDR_OFFSET)),
+ byte_order),
stream, demangle);
}
else
{
if (is_pascal_string_type (type, &length_pos, &length_size,
- &string_pos, &char_size, NULL))
+ &string_pos, &char_type, NULL))
{
- len = extract_unsigned_integer (valaddr + embedded_offset + length_pos, length_size);
- LA_PRINT_STRING (stream, valaddr + embedded_offset + string_pos, len, char_size, 0);
+ len = extract_unsigned_integer (valaddr + embedded_offset
+ + length_pos, length_size,
+ byte_order);
+ LA_PRINT_STRING (stream, char_type,
+ valaddr + embedded_offset + string_pos,
+ len, NULL, 0, options);
}
else
- pascal_object_print_value_fields (type, valaddr + embedded_offset, address, stream, format,
- recurse, pretty, NULL, 0);
- }
- break;
-
- case TYPE_CODE_ENUM:
- if (format)
- {
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
- break;
- }
- len = TYPE_NFIELDS (type);
- val = unpack_long (type, valaddr + embedded_offset);
- for (i = 0; i < len; i++)
- {
- QUIT;
- if (val == TYPE_FIELD_BITPOS (type, i))
- {
- break;
- }
- }
- if (i < len)
- {
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
- }
- else
- {
- print_longest (stream, 'd', 0, val);
- }
- break;
-
- case TYPE_CODE_FLAGS:
- if (format)
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
- else
- val_print_type_code_flags (type, valaddr + embedded_offset, stream);
- break;
-
- case TYPE_CODE_FUNC:
- if (format)
- {
- print_scalar_formatted (valaddr + embedded_offset, 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, "} ");
- /* Try to print what function it points to, and its address. */
- print_address_demangle (address, stream, demangle);
- break;
-
- case TYPE_CODE_BOOL:
- format = format ? format : output_format;
- if (format)
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
- else
- {
- val = unpack_long (type, valaddr + embedded_offset);
- if (val == 0)
- fputs_filtered ("false", stream);
- else if (val == 1)
- fputs_filtered ("true", stream);
- else
- {
- fputs_filtered ("true (", stream);
- fprintf_filtered (stream, "%ld)", (long int) val);
- }
+ pascal_object_print_value_fields (type, valaddr, embedded_offset,
+ address, stream, recurse,
+ original_value, options,
+ NULL, 0);
}
break;
- case TYPE_CODE_RANGE:
- /* FIXME: create_range_type does not set the unsigned bit in a
- range type (I think it probably should copy it from the target
- type), so we won't print values which are too large to
- fit in a signed integer correctly. */
- /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
- print with the target type, though, because the size of our type
- and the target type might differ). */
- /* FALLTHROUGH */
-
- case TYPE_CODE_INT:
- format = format ? format : output_format;
- if (format)
- {
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
- }
- else
- {
- val_print_type_code_int (type, valaddr + embedded_offset, stream);
- }
- break;
-
- case TYPE_CODE_CHAR:
- format = format ? format : output_format;
- if (format)
- {
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
- }
- else
- {
- val = unpack_long (type, valaddr + embedded_offset);
- if (TYPE_UNSIGNED (type))
- fprintf_filtered (stream, "%u", (unsigned int) val);
- else
- fprintf_filtered (stream, "%d", (int) val);
- fputs_filtered (" ", stream);
- LA_PRINT_CHAR ((unsigned char) val, stream);
- }
- break;
-
- case TYPE_CODE_FLT:
- if (format)
- {
- print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
- }
- else
- {
- print_floating (valaddr + embedded_offset, type, stream);
- }
- break;
-
- case TYPE_CODE_BITSTRING:
case TYPE_CODE_SET:
elttype = TYPE_INDEX_TYPE (type);
- CHECK_TYPEDEF (elttype);
+ elttype = check_typedef (elttype);
if (TYPE_STUB (elttype))
{
fprintf_filtered (stream, "");
@@ -467,15 +348,19 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
struct type *range = elttype;
LONGEST low_bound, high_bound;
int i;
- int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
int need_comma = 0;
- if (is_bitstring)
- fputs_filtered ("B'", stream);
- else
- fputs_filtered ("[", stream);
+ fputs_filtered ("[", stream);
i = get_discrete_bounds (range, &low_bound, &high_bound);
+ if (low_bound == 0 && high_bound == -1 && TYPE_LENGTH (type) > 0)
+ {
+ /* If we know the size of the set type, we can figure out the
+ maximum value. */
+ i = 0;
+ high_bound = TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1;
+ TYPE_HIGH_BOUND (range) = high_bound;
+ }
maybe_bad_bstring:
if (i < 0)
{
@@ -485,67 +370,57 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
for (i = low_bound; i <= high_bound; i++)
{
- int element = value_bit_index (type, valaddr + embedded_offset, i);
+ int element = value_bit_index (type,
+ valaddr + embedded_offset, i);
+
if (element < 0)
{
i = element;
goto maybe_bad_bstring;
}
- if (is_bitstring)
- fprintf_filtered (stream, "%d", element);
- else if (element)
+ if (element)
{
if (need_comma)
fputs_filtered (", ", stream);
print_type_scalar (range, i, stream);
need_comma = 1;
- if (i + 1 <= high_bound && value_bit_index (type, valaddr + embedded_offset, ++i))
+ if (i + 1 <= high_bound
+ && value_bit_index (type,
+ valaddr + embedded_offset, ++i))
{
int j = i;
+
fputs_filtered ("..", stream);
while (i + 1 <= high_bound
- && value_bit_index (type, valaddr + embedded_offset, ++i))
+ && value_bit_index (type,
+ valaddr + embedded_offset,
+ ++i))
j = i;
print_type_scalar (range, j, stream);
}
}
}
done:
- if (is_bitstring)
- fputs_filtered ("'", stream);
- else
- fputs_filtered ("]", stream);
+ fputs_filtered ("]", stream);
}
break;
- case TYPE_CODE_VOID:
- fprintf_filtered (stream, "void");
- break;
-
- case TYPE_CODE_ERROR:
- fprintf_filtered (stream, "");
- break;
-
- case TYPE_CODE_UNDEF:
- /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
- dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
- and no complete type for struct foo in that file. */
- fprintf_filtered (stream, "");
- break;
-
default:
- error (_("Invalid pascal type code %d in symbol table."), TYPE_CODE (type));
+ error (_("Invalid pascal type code %d in symbol table."),
+ TYPE_CODE (type));
}
gdb_flush (stream);
- return (0);
}
-int
-pascal_value_print (struct value *val, struct ui_file *stream, int format,
- enum val_prettyprint pretty)
+void
+pascal_value_print (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
{
struct type *type = value_type (val);
+ struct value_print_options opts = *options;
+
+ opts.deref_ref = 1;
/* If it is a pointer, indicate what it points to.
@@ -553,17 +428,17 @@ pascal_value_print (struct value *val, struct ui_file *stream, int format,
Object pascal: if it is a member pointer, we will take care
of that when we print it. */
- if (TYPE_CODE (type) == TYPE_CODE_PTR ||
- TYPE_CODE (type) == 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 (type) == TYPE_CODE_PTR &&
- TYPE_NAME (type) == NULL &&
- TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
+ type is indicated by the quoted string anyway. */
+ if (TYPE_CODE (type) == TYPE_CODE_PTR
+ && TYPE_NAME (type) == NULL
+ && TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
&& strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
{
- /* Print nothing */
+ /* Print nothing. */
}
else
{
@@ -572,18 +447,10 @@ pascal_value_print (struct value *val, struct ui_file *stream, int format,
fprintf_filtered (stream, ") ");
}
}
- return common_val_print (val, stream, format, 1, 0, pretty);
+ common_val_print (val, stream, 0, &opts, current_language);
}
-/******************************************************************************
- Inserted from cp-valprint
-******************************************************************************/
-
-extern int vtblprint; /* Controls printing of vtbl's */
-extern int objectprint; /* Controls looking up an object's derived type
- using what we find in its vtables. */
-static int pascal_static_field_print; /* Controls printing of static fields. */
static void
show_pascal_static_field_print (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
@@ -596,104 +463,16 @@ static struct obstack dont_print_vb_obstack;
static struct obstack dont_print_statmem_obstack;
static void pascal_object_print_static_field (struct value *,
- struct ui_file *, int, int,
- enum val_prettyprint);
+ struct ui_file *, int,
+ const struct value_print_options *);
static void pascal_object_print_value (struct type *, const gdb_byte *,
- CORE_ADDR, struct ui_file *,
- int, int, enum val_prettyprint,
+ int,
+ CORE_ADDR, struct ui_file *, int,
+ const struct value *,
+ const struct value_print_options *,
struct type **);
-void
-pascal_object_print_class_method (const gdb_byte *valaddr, struct type *type,
- struct ui_file *stream)
-{
- struct type *domain;
- struct fn_field *f = NULL;
- int j = 0;
- int len2;
- int offset;
- char *kind = "";
- CORE_ADDR addr;
- struct symbol *sym;
- unsigned len;
- unsigned int i;
- struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
-
- domain = TYPE_DOMAIN_TYPE (target_type);
- if (domain == (struct type *) NULL)
- {
- fprintf_filtered (stream, "");
- return;
- }
- addr = unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr);
- if (METHOD_PTR_IS_VIRTUAL (addr))
- {
- offset = METHOD_PTR_TO_VOFFSET (addr);
- len = TYPE_NFN_FIELDS (domain);
- for (i = 0; i < len; i++)
- {
- f = TYPE_FN_FIELDLIST1 (domain, i);
- len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
-
- check_stub_method_group (domain, i);
- for (j = 0; j < len2; j++)
- {
- if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
- {
- kind = "virtual ";
- goto common;
- }
- }
- }
- }
- else
- {
- sym = find_pc_function (addr);
- if (sym == 0)
- {
- error (_("invalid pointer to member function"));
- }
- len = TYPE_NFN_FIELDS (domain);
- for (i = 0; i < len; i++)
- {
- f = TYPE_FN_FIELDLIST1 (domain, i);
- len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
-
- check_stub_method_group (domain, i);
- for (j = 0; j < len2; j++)
- {
- if (DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
- goto common;
- }
- }
- }
-common:
- if (i < len)
- {
- char *demangled_name;
-
- fprintf_filtered (stream, "&");
- fputs_filtered (kind, stream);
- demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
- DMGL_ANSI | DMGL_PARAMS);
- if (demangled_name == NULL)
- fprintf_filtered (stream, "",
- TYPE_FN_FIELD_PHYSNAME (f, j));
- else
- {
- fputs_filtered (demangled_name, stream);
- xfree (demangled_name);
- }
- }
- else
- {
- fprintf_filtered (stream, "(");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, ") %d", (int) addr >> 3);
- }
-}
-
/* It was changed to this after 2.4.5. */
const char pascal_vtbl_ptr_name[] =
{'_', '_', 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
@@ -704,10 +483,10 @@ const char pascal_vtbl_ptr_name[] =
int
pascal_object_is_vtbl_ptr_type (struct type *type)
{
- char *typename = type_name_no_tag (type);
+ const char *type_name = type_name_no_tag (type);
- return (typename != NULL
- && strcmp (typename, pascal_vtbl_ptr_name) == 0);
+ return (type_name != NULL
+ && strcmp (type_name, pascal_vtbl_ptr_name) == 0);
}
/* Return truth value for the assertion that TYPE is of the type
@@ -722,11 +501,12 @@ pascal_object_is_vtbl_member (struct type *type)
if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
type = TYPE_TARGET_TYPE (type);
- if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
- || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* If not using
+ thunks. */
+ || TYPE_CODE (type) == TYPE_CODE_PTR) /* If using thunks. */
{
/* Virtual functions tables are full of pointers
- to virtual functions. */
+ to virtual functions. */
return pascal_object_is_vtbl_ptr_type (type);
}
}
@@ -738,7 +518,7 @@ pascal_object_is_vtbl_member (struct type *type)
c_val_print to print out a structure's fields:
pascal_object_print_value_fields and pascal_object_print_value.
- TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
+ TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
same meanings as in pascal_object_print_value and c_val_print.
DONT_PRINT is an array of baseclass types that we
@@ -746,17 +526,19 @@ pascal_object_is_vtbl_member (struct type *type)
void
pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
+ int offset,
CORE_ADDR address, struct ui_file *stream,
- int format, int recurse,
- enum val_prettyprint pretty,
+ int recurse,
+ const struct value *val,
+ const struct value_print_options *options,
struct type **dont_print_vb,
int dont_print_statmem)
{
int i, len, n_baseclasses;
- struct obstack tmp_obstack = { 0 };
- char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
+ char *last_dont_print
+ = (char *) obstack_next_free (&dont_print_statmem_obstack);
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
@@ -765,13 +547,15 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
/* Print out baseclasses such that we don't print
duplicates of virtual baseclasses. */
if (n_baseclasses > 0)
- pascal_object_print_value (type, valaddr, address, stream,
- format, recurse + 1, pretty, dont_print_vb);
+ pascal_object_print_value (type, valaddr, offset, address,
+ stream, recurse + 1, val,
+ options, dont_print_vb);
if (!len && n_baseclasses == 1)
fprintf_filtered (stream, "");
else
{
+ struct obstack tmp_obstack = dont_print_statmem_obstack;
int fields_seen = 0;
if (dont_print_statmem == 0)
@@ -779,20 +563,20 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
- tmp_obstack = dont_print_statmem_obstack;
obstack_finish (&dont_print_statmem_obstack);
}
for (i = n_baseclasses; i < len; i++)
{
/* If requested, skip printing of static fields. */
- if (!pascal_static_field_print && TYPE_FIELD_STATIC (type, i))
+ if (!options->pascal_static_field_print
+ && field_is_static (&TYPE_FIELD (type, i)))
continue;
if (fields_seen)
fprintf_filtered (stream, ", ");
else if (n_baseclasses > 0)
{
- if (pretty)
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
@@ -803,7 +587,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
}
fields_seen = 1;
- if (pretty)
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
@@ -812,38 +596,20 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
{
wrap_here (n_spaces (2 + 2 * recurse));
}
- if (inspect_it)
- {
- if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
- fputs_filtered ("\"( ptr \"", stream);
- else
- fputs_filtered ("\"( nodef \"", stream);
- if (TYPE_FIELD_STATIC (type, i))
- fputs_filtered ("static ", stream);
- fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
- DMGL_PARAMS | DMGL_ANSI);
- fputs_filtered ("\" \"", stream);
- fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
- DMGL_PARAMS | DMGL_ANSI);
- fputs_filtered ("\") \"", stream);
- }
- else
- {
- annotate_field_begin (TYPE_FIELD_TYPE (type, i));
-
- if (TYPE_FIELD_STATIC (type, i))
- fputs_filtered ("static ", stream);
- fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
- DMGL_PARAMS | DMGL_ANSI);
- annotate_field_name_end ();
- fputs_filtered (" = ", stream);
- annotate_field_value ();
- }
- if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
+ annotate_field_begin (TYPE_FIELD_TYPE (type, i));
+
+ if (field_is_static (&TYPE_FIELD (type, i)))
+ fputs_filtered ("static ", stream);
+ fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
+ language_cplus,
+ DMGL_PARAMS | DMGL_ANSI);
+ annotate_field_name_end ();
+ fputs_filtered (" = ", stream);
+ annotate_field_value ();
+
+ if (!field_is_static (&TYPE_FIELD (type, i))
+ && TYPE_FIELD_PACKED (type, i))
{
struct value *v;
@@ -853,12 +619,23 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
{
fputs_filtered ("", stream);
}
+ else if (value_bits_synthetic_pointer (val,
+ TYPE_FIELD_BITPOS (type,
+ i),
+ TYPE_FIELD_BITSIZE (type,
+ i)))
+ {
+ fputs_filtered (_(""), stream);
+ }
else
{
- v = value_from_longest (TYPE_FIELD_TYPE (type, i),
- unpack_field_as_long (type, valaddr, i));
+ struct value_print_options opts = *options;
- common_val_print (v, stream, format, 0, recurse + 1, pretty);
+ v = value_field_bitfield (type, i, valaddr, offset, val);
+
+ opts.deref_ref = 0;
+ common_val_print (v, stream, recurse + 1, &opts,
+ current_language);
}
}
else
@@ -867,29 +644,33 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
{
fputs_filtered ("", stream);
}
- else if (TYPE_FIELD_STATIC (type, i))
+ else if (field_is_static (&TYPE_FIELD (type, i)))
{
- /* struct value *v = value_static_field (type, i); v4.17 specific */
+ /* struct value *v = value_static_field (type, i);
+ v4.17 specific. */
struct value *v;
- v = value_from_longest (TYPE_FIELD_TYPE (type, i),
- unpack_field_as_long (type, valaddr, i));
+
+ v = value_field_bitfield (type, i, valaddr, offset, val);
if (v == NULL)
- fputs_filtered ("", stream);
+ val_print_optimized_out (NULL, stream);
else
- pascal_object_print_static_field (v, stream, format,
- recurse + 1, pretty);
+ pascal_object_print_static_field (v, stream, recurse + 1,
+ options);
}
else
{
+ struct value_print_options opts = *options;
+
+ opts.deref_ref = 0;
/* val_print (TYPE_FIELD_TYPE (type, i),
valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
stream, format, 0, recurse + 1, pretty); */
val_print (TYPE_FIELD_TYPE (type, i),
- valaddr, TYPE_FIELD_BITPOS (type, i) / 8,
- address + TYPE_FIELD_BITPOS (type, i) / 8,
- stream, format, 0, recurse + 1, pretty);
+ valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
+ address, stream, recurse + 1, val, &opts,
+ current_language);
}
}
annotate_field_end ();
@@ -903,7 +684,7 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
dont_print_statmem_obstack = tmp_obstack;
}
- if (pretty)
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
@@ -917,14 +698,16 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
static void
pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
+ int offset,
CORE_ADDR address, struct ui_file *stream,
- int format, int recurse,
- enum val_prettyprint pretty,
+ int recurse,
+ const struct value *val,
+ const struct value_print_options *options,
struct type **dont_print_vb)
{
- struct obstack tmp_obstack = { 0 };
struct type **last_dont_print
- = (struct type **) obstack_next_free (&dont_print_vb_obstack);
+ = (struct type **) obstack_next_free (&dont_print_vb_obstack);
+ struct obstack tmp_obstack = dont_print_vb_obstack;
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
if (dont_print_vb == 0)
@@ -932,25 +715,26 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
- tmp_obstack = dont_print_vb_obstack;
/* Bump up the high-water mark. Now alpha is omega. */
obstack_finish (&dont_print_vb_obstack);
}
for (i = 0; i < n_baseclasses; i++)
{
- int boffset;
+ int boffset = 0;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
- char *basename = TYPE_NAME (baseclass);
- const gdb_byte *base_valaddr;
+ const char *basename = type_name_no_tag (baseclass);
+ const gdb_byte *base_valaddr = NULL;
+ int thisoffset;
+ int skip = 0;
if (BASETYPE_VIA_VIRTUAL (type, i))
{
struct type **first_dont_print
- = (struct type **) obstack_base (&dont_print_vb_obstack);
+ = (struct type **) obstack_base (&dont_print_vb_obstack);
int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
- - first_dont_print;
+ - first_dont_print;
while (--j >= 0)
if (baseclass == first_dont_print[j])
@@ -959,9 +743,49 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
}
- boffset = baseclass_offset (type, i, valaddr, address);
+ thisoffset = offset;
+
+ TRY
+ {
+ boffset = baseclass_offset (type, i, valaddr, offset, address, val);
+ }
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ if (ex.error == NOT_AVAILABLE_ERROR)
+ skip = -1;
+ else
+ skip = 1;
+ }
+ END_CATCH
- if (pretty)
+ if (skip == 0)
+ {
+ /* The virtual base class pointer might have been clobbered by the
+ user program. Make sure that it still points to a valid memory
+ location. */
+
+ if (boffset < 0 || boffset >= TYPE_LENGTH (type))
+ {
+ gdb_byte *buf;
+ struct cleanup *back_to;
+
+ buf = (gdb_byte *) xmalloc (TYPE_LENGTH (baseclass));
+ back_to = make_cleanup (xfree, buf);
+
+ base_valaddr = buf;
+ if (target_read_memory (address + boffset, buf,
+ TYPE_LENGTH (baseclass)) != 0)
+ skip = 1;
+ address = address + boffset;
+ thisoffset = 0;
+ boffset = 0;
+ do_cleanups (back_to);
+ }
+ else
+ base_valaddr = valaddr;
+ }
+
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
@@ -973,27 +797,14 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
fputs_filtered (basename ? basename : "", stream);
fputs_filtered ("> = ", stream);
- /* The virtual base class pointer might have been clobbered by the
- user program. Make sure that it still points to a valid memory
- location. */
-
- if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type)))
- {
- /* FIXME (alloc): not safe is baseclass is really really big. */
- gdb_byte *buf = alloca (TYPE_LENGTH (baseclass));
- base_valaddr = buf;
- if (target_read_memory (address + boffset, buf,
- TYPE_LENGTH (baseclass)) != 0)
- boffset = -1;
- }
- else
- base_valaddr = valaddr + boffset;
-
- if (boffset == -1)
- fprintf_filtered (stream, "");
+ if (skip < 0)
+ val_print_unavailable (stream);
+ else if (skip > 0)
+ val_print_invalid_address (stream);
else
- pascal_object_print_value_fields (baseclass, base_valaddr, address + boffset,
- stream, format, recurse, pretty,
+ pascal_object_print_value_fields (baseclass, base_valaddr,
+ thisoffset + boffset, address,
+ stream, recurse, val, options,
(struct type **) obstack_base (&dont_print_vb_obstack),
0);
fputs_filtered (", ", stream);
@@ -1019,19 +830,27 @@ pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
static member classes in an obstack and refuse to print them more
than once.
- VAL contains the value to print, STREAM, RECURSE, and PRETTY
+ VAL contains the value to print, STREAM, RECURSE, and OPTIONS
have the same meanings as in c_val_print. */
static void
pascal_object_print_static_field (struct value *val,
- struct ui_file *stream, int format,
- int recurse, enum val_prettyprint pretty)
+ struct ui_file *stream,
+ int recurse,
+ const struct value_print_options *options)
{
struct type *type = value_type (val);
+ struct value_print_options opts;
+
+ if (value_entirely_optimized_out (val))
+ {
+ val_print_optimized_out (val, stream);
+ return;
+ }
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
- CORE_ADDR *first_dont_print;
+ CORE_ADDR *first_dont_print, addr;
int i;
first_dont_print
@@ -1041,90 +860,45 @@ pascal_object_print_static_field (struct value *val,
while (--i >= 0)
{
- if (VALUE_ADDRESS (val) == first_dont_print[i])
+ if (value_address (val) == first_dont_print[i])
{
- fputs_filtered ("",
+ fputs_filtered ("\
+",
stream);
return;
}
}
- obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
+ addr = value_address (val);
+ obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
sizeof (CORE_ADDR));
- CHECK_TYPEDEF (type);
- pascal_object_print_value_fields (type, value_contents (val), VALUE_ADDRESS (val),
- stream, format, recurse, pretty, NULL, 1);
+ type = check_typedef (type);
+ pascal_object_print_value_fields (type,
+ value_contents_for_printing (val),
+ value_embedded_offset (val),
+ addr,
+ stream, recurse,
+ val, options, NULL, 1);
return;
}
- common_val_print (val, stream, format, 0, recurse, pretty);
-}
-void
-pascal_object_print_class_member (const gdb_byte *valaddr, struct type *domain,
- struct ui_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;
- 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;
- fputs_filtered (prefix, stream);
- name = type_name_no_tag (domain);
- if (name)
- fputs_filtered (name, stream);
- else
- pascal_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, "%ld", (long int) (val >> 3));
+ opts = *options;
+ opts.deref_ref = 0;
+ common_val_print (val, stream, recurse, &opts, current_language);
}
-extern initialize_file_ftype _initialize_pascal_valprint; /* -Wmissing-prototypes */
+/* -Wmissing-prototypes */
+extern initialize_file_ftype _initialize_pascal_valprint;
void
_initialize_pascal_valprint (void)
{
add_setshow_boolean_cmd ("pascal_static-members", class_support,
- &pascal_static_field_print, _("\
+ &user_print_options.pascal_static_field_print, _("\
Set printing of pascal static members."), _("\
Show printing of pascal static members."), NULL,
NULL,
show_pascal_static_field_print,
&setprintlist, &showprintlist);
- /* Turn on printing of static fields. */
- pascal_static_field_print = 1;
-
}