static void
print_variable_at_address (struct type *type, const gdb_byte *valaddr,
struct ui_file *stream, int format,
int deref_ref, int recurse,
enum val_prettyprint pretty)
{
CORE_ADDR addr = unpack_pointer (type, valaddr);
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
fprintf_filtered (stream, "[");
fputs_filtered (paddress (addr), stream);
fprintf_filtered (stream, "] : ");
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));
common_val_print (deref_val, stream, format, deref_ref,
recurse, pretty);
}
else
fputs_filtered ("???", stream);
}
int
pascal_value_print (struct value *val, struct ui_file *stream, int format,
enum val_prettyprint pretty)
{
struct type *type = value_type (val);
/* If it is a pointer, indicate what it points to.
Print type also if it is a reference.
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)
{
/* 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
&& strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
{
/* Print nothing */
}
else
{
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
return common_val_print (val, stream, format, 1, 0, pretty);
}
static void
print_variable_at_address (struct type *type,
const gdb_byte *valaddr,
struct ui_file *stream,
int recurse,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (type);
CORE_ADDR addr = unpack_pointer (type, valaddr);
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
fprintf_filtered (stream, "[");
fputs_filtered (paddress (gdbarch, addr), stream);
fprintf_filtered (stream, "] : ");
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
struct value *deref_val =
value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
common_val_print (deref_val, stream, recurse, options, current_language);
}
else
fputs_filtered ("???", stream);
}
static void
ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
int offset, int offset_aligned, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *original_value,
const struct value_print_options *options,
const struct language_defn *language)
{
/* For references, the debugger is expected to print the value as
an address if DEREF_REF is null. But printing an address in place
of the object value would be confusing to an Ada programmer.
So, for Ada values, we print the actual dereferenced value
regardless. */
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
struct value *deref_val;
CORE_ADDR deref_val_int;
if (TYPE_CODE (elttype) == TYPE_CODE_UNDEF)
{
fputs_filtered ("<ref to undefined type>", stream);
return;
}
deref_val = coerce_ref_if_computed (original_value);
if (deref_val)
{
if (ada_is_tagged_type (value_type (deref_val), 1))
deref_val = ada_tag_value_at_base_address (deref_val);
common_val_print (deref_val, stream, recurse + 1, options,
language);
return;
}
deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
if (deref_val_int == 0)
{
fputs_filtered ("(null)", stream);
return;
}
deref_val
= ada_value_ind (value_from_pointer (lookup_pointer_type (elttype),
deref_val_int));
if (ada_is_tagged_type (value_type (deref_val), 1))
deref_val = ada_tag_value_at_base_address (deref_val);
/* Make sure that the object does not have an unreasonable size
before trying to print it. This can happen for instance with
references to dynamic objects whose contents is uninitialized
(Eg: an array whose bounds are not set yet). */
ada_ensure_varsize_limit (value_type (deref_val));
val_print (value_type (deref_val),
value_contents_for_printing (deref_val),
value_embedded_offset (deref_val),
value_address (deref_val), stream, recurse + 1,
deref_val, options, language);
}
static char *
ada_varobj_get_value_image (struct value *value,
struct value_print_options *opts)
{
char *result;
struct ui_file *buffer;
struct cleanup *old_chain;
buffer = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (buffer);
common_val_print (value, buffer, 0, opts, current_language);
result = ui_file_xstrdup (buffer, NULL);
do_cleanups (old_chain);
return result;
}
static void
pascal_object_print_static_field (struct value *val,
struct ui_file *stream,
int recurse,
const struct value_print_options *options)
{
struct type *type = value_type (val);
struct value_print_options opts;
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
CORE_ADDR *first_dont_print, addr;
int i;
first_dont_print
= (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
- first_dont_print;
while (--i >= 0)
{
if (value_address (val) == first_dont_print[i])
{
fputs_filtered ("<same as static member of an already seen type>",
stream);
return;
}
}
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), addr,
stream, recurse, NULL, options,
NULL, 1);
return;
}
opts = *options;
opts.deref_ref = 0;
common_val_print (val, stream, recurse, &opts, current_language);
}
static void
pascal_object_print_static_field (struct value *val,
struct ui_file *stream, int format,
int recurse, enum val_prettyprint pretty)
{
struct type *type = value_type (val);
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
CORE_ADDR *first_dont_print;
int i;
first_dont_print
= (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
- first_dont_print;
while (--i >= 0)
{
if (VALUE_ADDRESS (val) == first_dont_print[i])
{
fputs_filtered ("<same as static member of an already seen type>",
stream);
return;
}
}
obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
sizeof (CORE_ADDR));
CHECK_TYPEDEF (type);
pascal_object_print_value_fields (type, value_contents (val), VALUE_ADDRESS (val),
stream, format, recurse, pretty, NULL, 1);
return;
}
common_val_print (val, stream, format, 0, recurse, 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.
Print type also if it is a reference.
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)
{
/* 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
&& strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
{
/* Print nothing. */
}
else
{
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
}
}
common_val_print (val, stream, 0, &opts, current_language);
}
static void
list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
enum print_values values, int skip_unavailable)
{
struct cleanup *old_chain;
struct ui_out *uiout = current_uiout;
struct ui_file *stb;
gdb_assert (!arg->val || !arg->error);
gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
&& arg->error == NULL)
|| values == PRINT_SIMPLE_VALUES
|| (values == PRINT_ALL_VALUES
&& (arg->val != NULL || arg->error != NULL)));
gdb_assert (arg->entry_kind == print_entry_values_no
|| (arg->entry_kind == print_entry_values_only
&& (arg->val || arg->error)));
if (skip_unavailable && arg->val != NULL
&& (value_entirely_unavailable (arg->val)
/* A scalar object that does not have all bits available is
also considered unavailable, because all bits contribute
to its representation. */
|| (val_print_scalar_type_p (value_type (arg->val))
&& !value_bytes_available (arg->val,
value_embedded_offset (arg->val),
TYPE_LENGTH (value_type (arg->val))))))
return;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
if (values != PRINT_NO_VALUES || what == all)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb);
if (arg->entry_kind == print_entry_values_only)
fputs_filtered ("@entry", stb);
ui_out_field_stream (uiout, "name", stb);
if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))
ui_out_field_int (uiout, "arg", 1);
if (values == PRINT_SIMPLE_VALUES)
{
check_typedef (arg->sym->type);
type_print (arg->sym->type, "", stb, -1);
ui_out_field_stream (uiout, "type", stb);
}
if (arg->val || arg->error)
{
const char *error_message = NULL;
if (arg->error)
error_message = arg->error;
else
{
TRY
{
struct value_print_options opts;
get_no_prettyformat_print_options (&opts);
opts.deref_ref = 1;
common_val_print (arg->val, stb, 0, &opts,
language_def (SYMBOL_LANGUAGE (arg->sym)));
}
CATCH (except, RETURN_MASK_ERROR)
{
error_message = except.message;
}
END_CATCH
}
if (error_message != NULL)
fprintf_filtered (stb, _("<error reading variable: %s>"),
error_message);
ui_out_field_stream (uiout, "value", stb);
}
do_cleanups (old_chain);
}
void
pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct ui_file *stream,
int format, int recurse,
enum val_prettyprint pretty,
struct type **dont_print_vb,
int dont_print_statmem)
{
int i, len, n_baseclasses;
char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
CHECK_TYPEDEF (type);
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
/* 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);
if (!len && n_baseclasses == 1)
fprintf_filtered (stream, "<No data fields>");
else
{
struct obstack tmp_obstack = dont_print_statmem_obstack;
int fields_seen = 0;
if (dont_print_statmem == 0)
{
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
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))
continue;
if (fields_seen)
fprintf_filtered (stream, ", ");
else if (n_baseclasses > 0)
{
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;
if (pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
{
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))
{
struct value *v;
/* Bitfields require special handling, especially due to byte
order problems. */
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else
{
v = value_from_longest (TYPE_FIELD_TYPE (type, i),
unpack_field_as_long (type, valaddr, i));
common_val_print (v, stream, format, 0, recurse + 1, pretty);
}
}
else
{
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else if (TYPE_FIELD_STATIC (type, i))
{
/* 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));
if (v == NULL)
fputs_filtered ("<optimized out>", stream);
else
pascal_object_print_static_field (v, stream, format,
recurse + 1, pretty);
}
else
{
/* 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);
}
}
annotate_field_end ();
}
if (dont_print_statmem == 0)
{
/* Free the space used to deal with the printing
of the members from top level. */
obstack_free (&dont_print_statmem_obstack, last_dont_print);
dont_print_statmem_obstack = tmp_obstack;
}
if (pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
}
fprintf_filtered (stream, "}");
}
static enum string_repr_result
ppscm_print_string_repr (SCM printer, enum display_hint hint,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
struct gdbarch *gdbarch,
const struct language_defn *language)
{
struct value *replacement = NULL;
SCM str_scm;
enum string_repr_result result = STRING_REPR_ERROR;
str_scm = ppscm_pretty_print_one_value (printer, &replacement,
gdbarch, language);
if (gdbscm_is_false (str_scm))
{
result = STRING_REPR_NONE;
}
else if (scm_is_eq (str_scm, SCM_BOOL_T))
{
struct value_print_options opts = *options;
gdb_assert (replacement != NULL);
opts.addressprint = 0;
common_val_print (replacement, stream, recurse, &opts, language);
result = STRING_REPR_OK;
}
else if (scm_is_string (str_scm))
{
struct cleanup *cleanup;
size_t length;
char *string
= gdbscm_scm_to_string (str_scm, &length,
target_charset (gdbarch), 0 /*!strict*/, NULL);
cleanup = make_cleanup (xfree, string);
if (hint == HINT_STRING)
{
struct type *type = builtin_type (gdbarch)->builtin_char;
LA_PRINT_STRING (stream, type, (gdb_byte *) string,
length, NULL, 0, options);
}
else
{
/* Alas scm_to_stringn doesn't nul-terminate the string if we
ask for the length. */
size_t i;
for (i = 0; i < length; ++i)
{
if (string[i] == '\0')
fputs_filtered ("\\000", stream);
else
fputc_filtered (string[i], stream);
}
}
result = STRING_REPR_OK;
do_cleanups (cleanup);
}
else if (lsscm_is_lazy_string (str_scm))
{
struct value_print_options local_opts = *options;
local_opts.addressprint = 0;
lsscm_val_print_lazy_string (str_scm, stream, &local_opts);
result = STRING_REPR_OK;
}
else
{
gdb_assert (gdbscm_is_exception (str_scm));
ppscm_print_exception_unless_memory_error (str_scm, stream);
result = STRING_REPR_ERROR;
}
return result;
}
int
f_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)
{
unsigned int i = 0; /* Number of characters printed */
struct type *elttype;
LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRING:
f77_get_dynamic_length_of_aggregate (type);
LA_PRINT_STRING (stream, valaddr, TYPE_LENGTH (type), 1, 0);
break;
case TYPE_CODE_ARRAY:
fprintf_filtered (stream, "(");
f77_print_array (type, valaddr, address, stream, format,
deref_ref, recurse, pretty);
fprintf_filtered (stream, ")");
break;
case TYPE_CODE_PTR:
if (format && format != 's')
{
print_scalar_formatted (valaddr, type, format, 0, stream);
break;
}
else
{
addr = unpack_pointer (type, valaddr);
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* 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 (addressprint && format != 's')
deprecated_print_address_numeric (addr, 1, stream);
/* 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)
i = val_print_string (addr, -1, TYPE_LENGTH (elttype), 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_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (addressprint)
{
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
deprecated_print_address_numeric (addr, 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,
pretty);
}
else
fputs_filtered ("???", stream);
}
break;
case TYPE_CODE_FUNC:
if (format)
{
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, "} ");
/* Try to print what function it points to, and its address. */
print_address_demangle (address, stream, demangle);
break;
case TYPE_CODE_INT:
format = format ? format : output_format;
if (format)
print_scalar_formatted (valaddr, type, format, 0, stream);
else
{
val_print_type_code_int (type, valaddr, stream);
/* C and C++ has no single byte int type, char is used instead.
Since we don't know whether the value is really intended to
be used as an integer or a character, print the character
equivalent as well. */
if (TYPE_LENGTH (type) == 1)
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
stream);
}
}
break;
case TYPE_CODE_FLT:
if (format)
print_scalar_formatted (valaddr, type, format, 0, stream);
else
print_floating (valaddr, type, stream);
break;
case TYPE_CODE_VOID:
fprintf_filtered (stream, "VOID");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, "<unknown type>");
break;
case TYPE_CODE_RANGE:
/* FIXME, we should not ever have to print one of these yet. */
fprintf_filtered (stream, "<range type>");
break;
case TYPE_CODE_BOOL:
format = format ? format : output_format;
if (format)
print_scalar_formatted (valaddr, type, format, 0, stream);
else
{
val = 0;
switch (TYPE_LENGTH (type))
{
case 1:
val = unpack_long (builtin_type_f_logical_s1, valaddr);
break;
case 2:
val = unpack_long (builtin_type_f_logical_s2, valaddr);
break;
case 4:
val = unpack_long (builtin_type_f_logical, valaddr);
break;
default:
error (_("Logicals of length %d bytes not supported"),
TYPE_LENGTH (type));
}
if (val == 0)
fprintf_filtered (stream, ".FALSE.");
else if (val == 1)
fprintf_filtered (stream, ".TRUE.");
else
/* Not a legitimate logical type, print as an integer. */
{
/* Bash the type code temporarily. */
TYPE_CODE (type) = TYPE_CODE_INT;
f_val_print (type, valaddr, 0, address, stream, format,
deref_ref, recurse, pretty);
/* Restore the type code so later uses work as intended. */
TYPE_CODE (type) = TYPE_CODE_BOOL;
}
}
break;
case TYPE_CODE_COMPLEX:
switch (TYPE_LENGTH (type))
{
case 8:
type = builtin_type_f_real;
break;
case 16:
type = builtin_type_f_real_s8;
break;
case 32:
type = builtin_type_f_real_s16;
break;
default:
error (_("Cannot print out complex*%d variables"), TYPE_LENGTH (type));
}
fputs_filtered ("(", stream);
print_floating (valaddr, type, stream);
fputs_filtered (",", stream);
print_floating (valaddr + TYPE_LENGTH (type), type, stream);
fputs_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, "<incomplete type>");
break;
default:
error (_("Invalid F77 type code %d in symbol table."), TYPE_CODE (type));
}
gdb_flush (stream);
return 0;
}
void
pascal_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
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;
struct type *char_type;
CORE_ADDR addr;
int want_space = 0;
type = check_typedef (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
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);
if (options->prettyformat_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* 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 (options->stop_print_at_null)
{
unsigned int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
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, TYPE_TARGET_TYPE (type),
valaddr + embedded_offset, len, NULL, 0,
options);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members normally. */
if (pascal_object_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, "%d vtable entries", len - 1);
}
else
{
i = 0;
}
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 + embedded_offset;
goto print_unpacked_pointer;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
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.) */
/* Extract the address, assume that it is unsigned. */
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_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)))
{
if (want_space)
fputs_filtered (" ", stream);
fputs_filtered ("<", stream);
fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
want_space = 1;
}
if (vt_address && options->vtblprint)
{
struct value *vt_val;
struct symbol *wsym = NULL;
struct type *wtype;
struct block *block = NULL;
struct field_of_this_result is_this_fld;
if (want_space)
fputs_filtered (" ", stream);
if (msymbol.minsym != NULL)
wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
block,
VAR_DOMAIN, &is_this_fld).symbol;
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, recurse + 1, options,
current_language);
if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
}
}
return;
case TYPE_CODE_REF:
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 && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
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.) */
/* Extract the address, assume that it is unsigned. */
print_address_demangle
(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_type, NULL))
{
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, recurse,
original_value, options,
NULL, 0);
}
break;
case TYPE_CODE_SET:
elttype = TYPE_INDEX_TYPE (type);
elttype = check_typedef (elttype);
if (TYPE_STUB (elttype))
{
fprintf_filtered (stream, "<incomplete type>");
gdb_flush (stream);
break;
}
else
{
struct type *range = elttype;
LONGEST low_bound, high_bound;
int i;
int need_comma = 0;
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)
{
fputs_filtered ("<error value>", stream);
goto done;
}
for (i = low_bound; i <= high_bound; i++)
{
int element = value_bit_index (type,
valaddr + embedded_offset, i);
if (element < 0)
{
i = element;
goto maybe_bad_bstring;
}
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))
{
int j = i;
fputs_filtered ("..", stream);
while (i + 1 <= high_bound
&& value_bit_index (type,
valaddr + embedded_offset,
++i))
j = i;
print_type_scalar (range, j, stream);
}
}
}
done:
fputs_filtered ("]", stream);
}
break;
default:
error (_("Invalid pascal type code %d in symbol table."),
TYPE_CODE (type));
}
gdb_flush (stream);
}
int
f_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
CORE_ADDR address, 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 */
struct type *elttype;
LONGEST val;
CORE_ADDR addr;
int index;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRING:
f77_get_dynamic_length_of_aggregate (type);
LA_PRINT_STRING (stream, builtin_type (gdbarch)->builtin_char,
valaddr, TYPE_LENGTH (type), NULL, 0, options);
break;
case TYPE_CODE_ARRAY:
fprintf_filtered (stream, "(");
f77_print_array (type, valaddr, address, stream, recurse, original_value, options);
fprintf_filtered (stream, ")");
break;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
print_scalar_formatted (valaddr, type, options, 0, stream);
break;
}
else
{
addr = unpack_pointer (type, valaddr);
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_address_demangle (gdbarch, addr, stream, demangle);
/* Return value is irrelevant except for string pointers. */
return 0;
}
if (options->addressprint && options->format != 's')
fputs_filtered (paddress (gdbarch, addr), stream);
/* 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
&& (options->format == 0 || options->format == 's')
&& addr != 0)
i = val_print_string (TYPE_TARGET_TYPE (type), addr, -1, stream,
options);
/* 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_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (options->addressprint)
{
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
fputs_filtered (paddress (gdbarch, addr), stream);
if (options->deref_ref)
fputs_filtered (": ", stream);
}
/* De-reference the reference. */
if (options->deref_ref)
{
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
struct value *deref_val =
value_at
(TYPE_TARGET_TYPE (type),
unpack_pointer (type, valaddr + embedded_offset));
common_val_print (deref_val, stream, recurse,
options, current_language);
}
else
fputs_filtered ("???", stream);
}
break;
case TYPE_CODE_FUNC:
if (options->format)
{
print_scalar_formatted (valaddr, type, options, 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 (gdbarch, address, stream, demangle);
break;
case TYPE_CODE_INT:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
print_scalar_formatted (valaddr, type, &opts, 0, stream);
}
else
{
val_print_type_code_int (type, valaddr, stream);
/* C and C++ has no single byte int type, char is used instead.
Since we don't know whether the value is really intended to
be used as an integer or a character, print the character
equivalent as well. */
if (TYPE_LENGTH (type) == 1)
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
type, stream);
}
}
break;
case TYPE_CODE_FLAGS:
if (options->format)
print_scalar_formatted (valaddr, type, options, 0, stream);
else
val_print_type_code_flags (type, valaddr, stream);
break;
case TYPE_CODE_FLT:
if (options->format)
print_scalar_formatted (valaddr, type, options, 0, stream);
else
print_floating (valaddr, type, stream);
break;
case TYPE_CODE_VOID:
fprintf_filtered (stream, "VOID");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
break;
case TYPE_CODE_RANGE:
/* FIXME, we should not ever have to print one of these yet. */
fprintf_filtered (stream, "<range type>");
break;
case TYPE_CODE_BOOL:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
print_scalar_formatted (valaddr, type, &opts, 0, stream);
}
else
{
val = extract_unsigned_integer (valaddr,
TYPE_LENGTH (type), byte_order);
if (val == 0)
fprintf_filtered (stream, ".FALSE.");
else if (val == 1)
fprintf_filtered (stream, ".TRUE.");
else
/* Not a legitimate logical type, print as an integer. */
{
/* Bash the type code temporarily. */
TYPE_CODE (type) = TYPE_CODE_INT;
val_print (type, valaddr, 0, address, stream, recurse,
original_value, options, current_language);
/* Restore the type code so later uses work as intended. */
TYPE_CODE (type) = TYPE_CODE_BOOL;
}
}
break;
case TYPE_CODE_COMPLEX:
type = TYPE_TARGET_TYPE (type);
fputs_filtered ("(", stream);
print_floating (valaddr, type, stream);
fputs_filtered (",", stream);
print_floating (valaddr + TYPE_LENGTH (type), type, stream);
fputs_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, "<incomplete type>");
break;
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
/* Starting from the Fortran 90 standard, Fortran supports derived
types. */
fprintf_filtered (stream, "( ");
for (index = 0; index < TYPE_NFIELDS (type); index++)
{
int offset = TYPE_FIELD_BITPOS (type, index) / 8;
val_print (TYPE_FIELD_TYPE (type, index), valaddr + offset,
embedded_offset, address, stream, recurse + 1,
original_value, options, current_language);
if (index != TYPE_NFIELDS (type) - 1)
fputs_filtered (", ", stream);
}
fprintf_filtered (stream, " )");
break;
default:
error (_("Invalid F77 type code %d in symbol table."), TYPE_CODE (type));
}
gdb_flush (stream);
return 0;
}
/* Helper for gdbpy_apply_val_pretty_printer that formats children of the
printer, if any exist. If is_py_none is true, then nothing has
been printed by to_string, and format output accordingly. */
static void
print_children (PyObject *printer, const char *hint,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
const struct language_defn *language,
int is_py_none)
{
int is_map, is_array, done_flag, pretty;
unsigned int i;
if (! PyObject_HasAttr (printer, gdbpy_children_cst))
return;
/* If we are printing a map or an array, we want some special
formatting. */
is_map = hint && ! strcmp (hint, "map");
is_array = hint && ! strcmp (hint, "array");
gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
NULL));
if (children == NULL)
{
print_stack_unless_memory_error (stream);
return;
}
gdbpy_ref<> iter (PyObject_GetIter (children.get ()));
if (iter == NULL)
{
print_stack_unless_memory_error (stream);
return;
}
/* Use the prettyformat_arrays option if we are printing an array,
and the pretty option otherwise. */
if (is_array)
pretty = options->prettyformat_arrays;
else
{
if (options->prettyformat == Val_prettyformat)
pretty = 1;
else
pretty = options->prettyformat_structs;
}
/* Manufacture a dummy Python frame to work around Python 2.4 bug,
where it insists on having a non-NULL tstate->frame when
a generator is called. */
#ifndef IS_PY3K
dummy_python_frame frame;
if (frame.failed ())
{
gdbpy_print_stack ();
return;
}
#endif
done_flag = 0;
for (i = 0; i < options->print_max; ++i)
{
PyObject *py_v;
const char *name;
gdbpy_ref<> item (PyIter_Next (iter.get ()));
if (item == NULL)
{
if (PyErr_Occurred ())
print_stack_unless_memory_error (stream);
/* Set a flag so we can know whether we printed all the
available elements. */
else
done_flag = 1;
break;
}
if (! PyTuple_Check (item.get ()) || PyTuple_Size (item.get ()) != 2)
{
PyErr_SetString (PyExc_TypeError,
_("Result of children iterator not a tuple"
" of two elements."));
gdbpy_print_stack ();
continue;
}
if (! PyArg_ParseTuple (item.get (), "sO", &name, &py_v))
{
/* The user won't necessarily get a stack trace here, so provide
more context. */
if (gdbpy_print_python_errors_p ())
fprintf_unfiltered (gdb_stderr,
_("Bad result from children iterator.\n"));
gdbpy_print_stack ();
continue;
}
/* Print initial "{". For other elements, there are three
cases:
1. Maps. Print a "," after each value element.
2. Arrays. Always print a ",".
3. Other. Always print a ",". */
if (i == 0)
{
if (is_py_none)
fputs_filtered ("{", stream);
else
fputs_filtered (" = {", stream);
}
else if (! is_map || i % 2 == 0)
fputs_filtered (pretty ? "," : ", ", stream);
/* In summary mode, we just want to print "= {...}" if there is
a value. */
if (options->summary)
{
/* This increment tricks the post-loop logic to print what
we want. */
++i;
/* Likewise. */
pretty = 0;
break;
}
if (! is_map || i % 2 == 0)
{
if (pretty)
{
fputs_filtered ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
wrap_here (n_spaces (2 + 2 *recurse));
}
if (is_map && i % 2 == 0)
fputs_filtered ("[", stream);
else if (is_array)
{
/* We print the index, not whatever the child method
returned as the name. */
if (options->print_array_indexes)
fprintf_filtered (stream, "[%d] = ", i);
}
else if (! is_map)
{
fputs_filtered (name, stream);
fputs_filtered (" = ", stream);
}
if (gdbpy_is_lazy_string (py_v))
{
CORE_ADDR addr;
struct type *type;
long length;
gdb::unique_xmalloc_ptr<char> encoding;
struct value_print_options local_opts = *options;
gdbpy_extract_lazy_string (py_v, &addr, &type, &length, &encoding);
local_opts.addressprint = 0;
val_print_string (type, encoding.get (), addr, (int) length, stream,
&local_opts);
}
else if (gdbpy_is_string (py_v))
{
gdb::unique_xmalloc_ptr<char> output;
output = python_string_to_host_string (py_v);
if (!output)
gdbpy_print_stack ();
else
fputs_filtered (output.get (), stream);
}
else
{
struct value *value = convert_value_from_python (py_v);
if (value == NULL)
{
gdbpy_print_stack ();
error (_("Error while executing Python code."));
}
else
common_val_print (value, stream, recurse + 1, options, language);
}
if (is_map && i % 2 == 0)
fputs_filtered ("] = ", stream);
}
if (i)
{
if (!done_flag)
{
if (pretty)
{
fputs_filtered ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
fputs_filtered ("...", stream);
}
if (pretty)
{
fputs_filtered ("\n", stream);
print_spaces_filtered (2 * recurse, stream);
}
fputs_filtered ("}", stream);
}
}
static enum string_repr_result
print_string_repr (PyObject *printer, const char *hint,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
const struct language_defn *language,
struct gdbarch *gdbarch)
{
struct value *replacement = NULL;
enum string_repr_result result = string_repr_ok;
gdbpy_ref<> py_str (pretty_print_one_value (printer, &replacement));
if (py_str != NULL)
{
if (py_str == Py_None)
result = string_repr_none;
else if (gdbpy_is_lazy_string (py_str.get ()))
{
CORE_ADDR addr;
long length;
struct type *type;
gdb::unique_xmalloc_ptr<char> encoding;
struct value_print_options local_opts = *options;
gdbpy_extract_lazy_string (py_str.get (), &addr, &type,
&length, &encoding);
local_opts.addressprint = 0;
val_print_string (type, encoding.get (), addr, (int) length,
stream, &local_opts);
}
else
{
gdbpy_ref<> string
(python_string_to_target_python_string (py_str.get ()));
if (string != NULL)
{
char *output;
long length;
struct type *type;
#ifdef IS_PY3K
output = PyBytes_AS_STRING (string.get ());
length = PyBytes_GET_SIZE (string.get ());
#else
output = PyString_AsString (string.get ());
length = PyString_Size (string.get ());
#endif
type = builtin_type (gdbarch)->builtin_char;
if (hint && !strcmp (hint, "string"))
LA_PRINT_STRING (stream, type, (gdb_byte *) output,
length, NULL, 0, options);
else
fputs_filtered (output, stream);
}
else
{
result = string_repr_error;
print_stack_unless_memory_error (stream);
}
}
}
else if (replacement)
{
struct value_print_options opts = *options;
opts.addressprint = 0;
common_val_print (replacement, stream, recurse, &opts, language);
}
else
{
result = string_repr_error;
print_stack_unless_memory_error (stream);
}
return result;
}
static enum string_repr_result
print_string_repr (PyObject *printer, const char *hint,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
const struct language_defn *language,
struct gdbarch *gdbarch)
{
struct value *replacement = NULL;
PyObject *py_str = NULL;
enum string_repr_result result = string_repr_ok;
py_str = pretty_print_one_value (printer, &replacement);
if (py_str)
{
struct cleanup *cleanup = make_cleanup_py_decref (py_str);
if (py_str == Py_None)
result = string_repr_none;
else if (gdbpy_is_lazy_string (py_str))
{
CORE_ADDR addr;
long length;
struct type *type;
char *encoding = NULL;
struct value_print_options local_opts = *options;
make_cleanup (free_current_contents, &encoding);
gdbpy_extract_lazy_string (py_str, &addr, &type,
&length, &encoding);
local_opts.addressprint = 0;
val_print_string (type, encoding, addr, (int) length,
stream, &local_opts);
}
else
{
PyObject *string;
string = python_string_to_target_python_string (py_str);
if (string)
{
char *output;
long length;
struct type *type;
make_cleanup_py_decref (string);
#ifdef IS_PY3K
output = PyBytes_AS_STRING (string);
length = PyBytes_GET_SIZE (string);
#else
output = PyString_AsString (string);
length = PyString_Size (string);
#endif
type = builtin_type (gdbarch)->builtin_char;
if (hint && !strcmp (hint, "string"))
LA_PRINT_STRING (stream, type, (gdb_byte *) output,
length, NULL, 0, options);
else
fputs_filtered (output, stream);
}
else
{
result = string_repr_error;
print_stack_unless_memory_error (stream);
}
}
do_cleanups (cleanup);
}
else if (replacement)
{
struct value_print_options opts = *options;
opts.addressprint = 0;
common_val_print (replacement, stream, recurse, &opts, language);
}
else
{
result = string_repr_error;
print_stack_unless_memory_error (stream);
}
return result;
}
int
c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int recurse,
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;
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
unsigned eltlen;
LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
{
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
if (options->prettyprint_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* Print arrays of textual chars with a string syntax. */
if (c_textual_element_type (unresolved_elttype, options->format))
{
/* If requested, look for the first null char and only print
elements up to it. */
if (options->stop_print_at_null)
{
unsigned int temp_len;
for (temp_len = 0;
(temp_len < len
&& temp_len < options->print_max
&& extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
eltlen, byte_order) != 0);
++temp_len)
;
len = temp_len;
}
LA_PRINT_STRING (stream, unresolved_elttype,
valaddr + embedded_offset, len,
NULL, 0, options);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members normally. */
if (cp_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, _("%d vtable entries"), len - 1);
}
else
{
i = 0;
}
val_print_array_elements (type, valaddr + embedded_offset, address, stream,
recurse, options, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
addr = address;
goto print_unpacked_pointer;
case TYPE_CODE_MEMBERPTR:
if (options->format)
{
print_scalar_formatted (valaddr + embedded_offset, type,
options, 0, stream);
break;
}
cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
break;
case TYPE_CODE_METHODPTR:
cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
break;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
print_scalar_formatted (valaddr + embedded_offset, type,
options, 0, stream);
break;
}
if (options->vtblprint && cp_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.) */
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
break;
}
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
{
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer:
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
/* Return value is irrelevant except for string pointers. */
return (0);
}
if (options->addressprint)
fputs_filtered (paddress (gdbarch, addr), stream);
/* For a pointer to a textual type, also print the string
pointed to, unless pointer is null. */
if (c_textual_element_type (unresolved_elttype, options->format)
&& addr != 0)
{
i = val_print_string (unresolved_elttype, addr, -1, stream,
options);
}
else if (cp_is_vtbl_member (type))
{
/* print vtbl's nicely */
CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (vt_address);
if ((msymbol != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (">", stream);
}
if (vt_address && options->vtblprint)
{
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 (SYMBOL_LINKAGE_NAME (msymbol), block,
VAR_DOMAIN, &is_this_fld);
if (wsym)
{
wtype = SYMBOL_TYPE (wsym);
}
else
{
wtype = unresolved_elttype;
}
vt_val = value_at (wtype, vt_address);
common_val_print (vt_val, stream, recurse + 1, options,
current_language);
if (options->pretty)
{
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_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (options->addressprint)
{
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
fputs_filtered (paddress (gdbarch, addr), stream);
if (options->deref_ref)
fputs_filtered (": ", stream);
}
/* De-reference the reference. */
if (options->deref_ref)
{
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
{
struct value *deref_val =
value_at
(TYPE_TARGET_TYPE (type),
unpack_pointer (type, valaddr + embedded_offset));
common_val_print (deref_val, stream, recurse, options,
current_language);
}
else
fputs_filtered ("???", stream);
}
break;
case TYPE_CODE_UNION:
if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
/*FIXME: Abstract this away */
if (options->vtblprint && cp_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.) */
int offset = (embedded_offset +
TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
CORE_ADDR addr
= extract_typed_address (valaddr + offset, field_type);
print_function_pointer_address (gdbarch, addr, stream,
options->addressprint);
}
else
cp_print_value_fields_rtti (type, valaddr,
embedded_offset, address, stream,
recurse, options, NULL, 0);
break;
case TYPE_CODE_ENUM:
if (options->format)
{
print_scalar_formatted (valaddr + embedded_offset, type,
options, 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 (options->format)
print_scalar_formatted (valaddr + embedded_offset, type,
options, 0, stream);
else
val_print_type_code_flags (type, valaddr + embedded_offset, stream);
break;
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
if (options->format)
{
print_scalar_formatted (valaddr + embedded_offset, type,
options, 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 (gdbarch, address, stream, demangle);
break;
case TYPE_CODE_BOOL:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
print_scalar_formatted (valaddr + embedded_offset, type,
&opts, 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
print_longest (stream, 'd', 0, val);
}
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:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
print_scalar_formatted (valaddr + embedded_offset, type,
&opts, 0, stream);
}
else
{
val_print_type_code_int (type, valaddr + embedded_offset, stream);
/* C and C++ has no single byte int type, char is used instead.
Since we don't know whether the value is really intended to
be used as an integer or a character, print the character
equivalent as well. */
if (c_textual_element_type (unresolved_type, options->format))
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
unresolved_type, stream);
}
}
break;
case TYPE_CODE_CHAR:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
print_scalar_formatted (valaddr + embedded_offset, type,
&opts, 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, unresolved_type, stream);
}
break;
case TYPE_CODE_FLT:
if (options->format)
{
print_scalar_formatted (valaddr + embedded_offset, type,
options, 0, stream);
}
else
{
print_floating (valaddr + embedded_offset, type, stream);
}
break;
case TYPE_CODE_DECFLOAT:
if (options->format)
print_scalar_formatted (valaddr + embedded_offset, type,
options, 0, stream);
else
print_decimal_floating (valaddr + embedded_offset, type, stream);
break;
case TYPE_CODE_VOID:
fprintf_filtered (stream, "void");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, _("<error type>"));
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, _("<incomplete type>"));
break;
case TYPE_CODE_COMPLEX:
if (options->format)
print_scalar_formatted (valaddr + embedded_offset,
TYPE_TARGET_TYPE (type),
options, 0, stream);
else
print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
stream);
fprintf_filtered (stream, " + ");
if (options->format)
print_scalar_formatted (valaddr + embedded_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
TYPE_TARGET_TYPE (type),
options, 0, stream);
else
print_floating (valaddr + embedded_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
TYPE_TARGET_TYPE (type),
stream);
fprintf_filtered (stream, " * I");
break;
default:
error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type));
}
gdb_flush (stream);
return (0);
}
void
pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
int offset,
CORE_ADDR address, struct ui_file *stream,
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;
char *last_dont_print
= (char *) obstack_next_free (&dont_print_statmem_obstack);
type = check_typedef (type);
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
/* Print out baseclasses such that we don't print
duplicates of virtual baseclasses. */
if (n_baseclasses > 0)
pascal_object_print_value (type, valaddr, offset, address,
stream, recurse + 1, val,
options, dont_print_vb);
if (!len && n_baseclasses == 1)
fprintf_filtered (stream, "<No data fields>");
else
{
struct obstack tmp_obstack = dont_print_statmem_obstack;
int fields_seen = 0;
if (dont_print_statmem == 0)
{
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
obstack_finish (&dont_print_statmem_obstack);
}
for (i = n_baseclasses; i < len; i++)
{
/* If requested, skip printing of static fields. */
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 (options->prettyformat)
{
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;
if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
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;
/* Bitfields require special handling, especially due to byte
order problems. */
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else if (value_bits_synthetic_pointer (val,
TYPE_FIELD_BITPOS (type,
i),
TYPE_FIELD_BITSIZE (type,
i)))
{
fputs_filtered (_("<synthetic pointer>"), stream);
}
else
{
struct value_print_options opts = *options;
v = value_field_bitfield (type, i, valaddr, offset, val);
opts.deref_ref = 0;
common_val_print (v, stream, recurse + 1, &opts,
current_language);
}
}
else
{
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else if (field_is_static (&TYPE_FIELD (type, i)))
{
/* struct value *v = value_static_field (type, i);
v4.17 specific. */
struct value *v;
v = value_field_bitfield (type, i, valaddr, offset, val);
if (v == NULL)
val_print_optimized_out (NULL, stream);
else
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, offset + TYPE_FIELD_BITPOS (type, i) / 8,
address, stream, recurse + 1, val, &opts,
current_language);
}
}
annotate_field_end ();
}
if (dont_print_statmem == 0)
{
/* Free the space used to deal with the printing
of the members from top level. */
obstack_free (&dont_print_statmem_obstack, last_dont_print);
dont_print_statmem_obstack = tmp_obstack;
}
if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
}
fprintf_filtered (stream, "}");
}
static void
java_print_value_fields (struct type *type, const gdb_byte *valaddr,
CORE_ADDR address, struct ui_file *stream,
int recurse,
const struct value_print_options *options)
{
int i, len, n_baseclasses;
CHECK_TYPEDEF (type);
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
if (n_baseclasses > 0)
{
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
for (i = 0; i < n_baseclasses; i++)
{
int boffset;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
char *basename = TYPE_NAME (baseclass);
const gdb_byte *base_valaddr;
if (BASETYPE_VIA_VIRTUAL (type, i))
continue;
if (basename != NULL && strcmp (basename, "java.lang.Object") == 0)
continue;
boffset = 0;
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * (recurse + 1), stream);
}
fputs_filtered ("<", stream);
/* Not sure what the best notation is in the case where there is no
baseclass name. */
fputs_filtered (basename ? basename : "", stream);
fputs_filtered ("> = ", stream);
base_valaddr = valaddr;
java_print_value_fields (baseclass, base_valaddr, address + boffset,
stream, recurse + 1, options);
fputs_filtered (", ", stream);
}
}
if (!len && n_baseclasses == 1)
fprintf_filtered (stream, "<No data fields>");
else
{
int fields_seen = 0;
for (i = n_baseclasses; i < len; i++)
{
/* If requested, skip printing of static fields. */
if (field_is_static (&TYPE_FIELD (type, i)))
{
char *name = TYPE_FIELD_NAME (type, i);
if (!options->static_field_print)
continue;
if (name != NULL && strcmp (name, "class") == 0)
continue;
}
if (fields_seen)
fprintf_filtered (stream, ", ");
else if (n_baseclasses > 0)
{
if (options->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;
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
if (options->inspect_it)
{
if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
fputs_filtered ("\"( ptr \"", stream);
else
fputs_filtered ("\"( nodef \"", stream);
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);
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 (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;
/* Bitfields require special handling, especially due to byte
order problems. */
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else
{
struct value_print_options opts;
v = value_from_longest (TYPE_FIELD_TYPE (type, i),
unpack_field_as_long (type, valaddr, i));
opts = *options;
opts.deref_ref = 0;
common_val_print (v, stream, recurse + 1,
&opts, current_language);
}
}
else
{
if (TYPE_FIELD_IGNORE (type, i))
{
fputs_filtered ("<optimized out or zero length>", stream);
}
else if (field_is_static (&TYPE_FIELD (type, i)))
{
struct value *v = value_static_field (type, i);
if (v == NULL)
fputs_filtered ("<optimized out>", stream);
else
{
struct value_print_options opts;
struct type *t = check_typedef (value_type (v));
if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
v = value_addr (v);
opts = *options;
opts.deref_ref = 0;
common_val_print (v, stream, recurse + 1,
&opts, current_language);
}
}
else if (TYPE_FIELD_TYPE (type, i) == NULL)
fputs_filtered ("<unknown type>", stream);
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, 0,
address + TYPE_FIELD_BITPOS (type, i) / 8,
stream, recurse + 1, &opts,
current_language);
}
}
annotate_field_end ();
}
if (options->pretty)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
}
fprintf_filtered (stream, "}");
}
void
c_val_print (struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
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;
struct type *elttype, *unresolved_elttype;
struct type *unresolved_type = type;
unsigned eltlen;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
{
LONGEST low_bound, high_bound;
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
eltlen = TYPE_LENGTH (elttype);
len = high_bound - low_bound + 1;
if (options->prettyformat_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* Print arrays of textual chars with a string syntax, as
long as the entire array is valid. */
if (c_textual_element_type (unresolved_elttype,
options->format)
&& value_bytes_available (original_value, embedded_offset,
TYPE_LENGTH (type))
&& value_bits_valid (original_value,
TARGET_CHAR_BIT * embedded_offset,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
int force_ellipses = 0;
/* If requested, look for the first null char and only
print elements up to it. */
if (options->stop_print_at_null)
{
unsigned int temp_len;
for (temp_len = 0;
(temp_len < len
&& temp_len < options->print_max
&& extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
eltlen, byte_order) != 0);
++temp_len)
;
/* Force LA_PRINT_STRING to print ellipses if
we've printed the maximum characters and
the next character is not \000. */
if (temp_len == options->print_max && temp_len < len)
{
ULONGEST val
= extract_unsigned_integer (valaddr + embedded_offset
+ temp_len * eltlen,
eltlen, byte_order);
if (val != 0)
force_ellipses = 1;
}
len = temp_len;
}
LA_PRINT_STRING (stream, unresolved_elttype,
valaddr + embedded_offset, len,
NULL, force_ellipses, options);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members
normally. */
if (cp_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, _("%d vtable entries"),
len - 1);
}
else
{
i = 0;
}
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 + embedded_offset;
goto print_unpacked_pointer;
case TYPE_CODE_METHODPTR:
cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
break;
case TYPE_CODE_PTR:
if (options->format && options->format != 's')
{
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, options, 0, stream);
break;
}
if (options->vtblprint && cp_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.) */
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
print_function_pointer_address (options, gdbarch, addr, stream);
break;
}
unresolved_elttype = TYPE_TARGET_TYPE (type);
elttype = check_typedef (unresolved_elttype);
{
int want_space;
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer:
want_space = 0;
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (options, gdbarch, addr, stream);
return;
}
if (options->symbol_print)
want_space = print_address_demangle (options, gdbarch, addr,
stream, demangle);
else if (options->addressprint)
{
fputs_filtered (paddress (gdbarch, addr), stream);
want_space = 1;
}
/* For a pointer to a textual type, also print the string
pointed to, unless pointer is null. */
if (c_textual_element_type (unresolved_elttype,
options->format)
&& addr != 0)
{
if (want_space)
fputs_filtered (" ", stream);
i = val_print_string (unresolved_elttype, NULL,
addr, -1,
stream, options);
}
else if (cp_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 == SYMBOL_VALUE_ADDRESS (msymbol.minsym)))
{
if (want_space)
fputs_filtered (" ", stream);
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
want_space = 1;
}
if (vt_address && options->vtblprint)
{
struct value *vt_val;
struct symbol *wsym = (struct symbol *) NULL;
struct type *wtype;
struct block *block = (struct block *) NULL;
struct field_of_this_result is_this_fld;
if (want_space)
fputs_filtered (" ", stream);
if (msymbol.minsym != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym),
block, VAR_DOMAIN,
&is_this_fld);
if (wsym)
{
wtype = SYMBOL_TYPE (wsym);
}
else
{
wtype = unresolved_elttype;
}
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;
}
break;
case TYPE_CODE_UNION:
if (recurse && !options->unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
/*FIXME: Abstract this away. */
if (options->vtblprint && cp_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.) */
int offset = (embedded_offset
+ TYPE_FIELD_BITPOS (type,
VTBL_FNADDR_OFFSET) / 8);
struct type *field_type = TYPE_FIELD_TYPE (type,
VTBL_FNADDR_OFFSET);
CORE_ADDR addr
= extract_typed_address (valaddr + offset, field_type);
print_function_pointer_address (options, gdbarch, addr, stream);
}
else
cp_print_value_fields_rtti (type, valaddr,
embedded_offset, address,
stream, recurse,
original_value, options,
NULL, 0);
break;
case TYPE_CODE_INT:
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
val_print_scalar_formatted (type, valaddr, embedded_offset,
original_value, &opts, 0, stream);
}
else
{
val_print_type_code_int (type, valaddr + embedded_offset,
stream);
/* C and C++ has no single byte int type, char is used
instead. Since we don't know whether the value is really
intended to be used as an integer or a character, print
the character equivalent as well. */
if (c_textual_element_type (unresolved_type, options->format))
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
unresolved_type, stream);
}
}
break;
case TYPE_CODE_MEMBERPTR:
if (!options->format)
{
cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
break;
}
/* FALLTHROUGH */
case TYPE_CODE_REF:
case TYPE_CODE_ENUM:
case TYPE_CODE_FLAGS:
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
case TYPE_CODE_BOOL:
case TYPE_CODE_RANGE:
case TYPE_CODE_FLT:
case TYPE_CODE_DECFLOAT:
case TYPE_CODE_VOID:
case TYPE_CODE_ERROR:
case TYPE_CODE_UNDEF:
case TYPE_CODE_COMPLEX:
case TYPE_CODE_CHAR:
default:
generic_val_print (type, valaddr, embedded_offset, address,
stream, recurse, original_value, options,
&c_decorations);
break;
}
gdb_flush (stream);
}
int
scm_value_print (struct value *val, struct ui_file *stream, int format,
enum val_prettyprint pretty)
{
return (common_val_print (val, stream, format, 1, 0, pretty));
}
int
java_value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options)
{
struct gdbarch *gdbarch = get_type_arch (value_type (val));
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct type *type;
CORE_ADDR address;
int i;
char *name;
struct value_print_options opts;
type = value_type (val);
address = value_address (val);
if (is_object_type (type))
{
CORE_ADDR obj_addr;
/* Get the run-time type, and cast the object into that */
obj_addr = unpack_pointer (type, value_contents (val));
if (obj_addr != 0)
{
type = type_from_class (gdbarch, java_class_from_object (val));
type = lookup_pointer_type (type);
val = value_at (type, address);
}
}
if (TYPE_CODE (type) == TYPE_CODE_PTR && !value_logical_not (val))
type_print (TYPE_TARGET_TYPE (type), "", stream, -1);
name = TYPE_TAG_NAME (type);
if (TYPE_CODE (type) == TYPE_CODE_STRUCT && name != NULL
&& (i = strlen (name), name[i - 1] == ']'))
{
gdb_byte buf4[4];
long length;
unsigned int things_printed = 0;
int reps;
struct type *el_type
= java_primitive_type_from_name (gdbarch, name, i - 2);
i = 0;
read_memory (address + get_java_object_header_size (gdbarch), buf4, 4);
length = (long) extract_signed_integer (buf4, 4, byte_order);
fprintf_filtered (stream, "{length: %ld", length);
if (el_type == NULL)
{
CORE_ADDR element;
CORE_ADDR next_element = -1; /* dummy initial value */
/* Skip object header and length. */
address += get_java_object_header_size (gdbarch) + 4;
while (i < length && things_printed < options->print_max)
{
gdb_byte *buf;
buf = alloca (gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT);
fputs_filtered (", ", stream);
wrap_here (n_spaces (2));
if (i > 0)
element = next_element;
else
{
read_memory (address, buf, sizeof (buf));
address += gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT;
/* FIXME: cagney/2003-05-24: Bogus or what. It
pulls a host sized pointer out of the target and
then extracts that as an address (while assuming
that the address is unsigned)! */
element = extract_unsigned_integer (buf, sizeof (buf),
byte_order);
}
for (reps = 1; i + reps < length; reps++)
{
read_memory (address, buf, sizeof (buf));
address += gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT;
/* FIXME: cagney/2003-05-24: Bogus or what. It
pulls a host sized pointer out of the target and
then extracts that as an address (while assuming
that the address is unsigned)! */
next_element = extract_unsigned_integer (buf, sizeof (buf),
byte_order);
if (next_element != element)
break;
}
if (reps == 1)
fprintf_filtered (stream, "%d: ", i);
else
fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);
if (element == 0)
fprintf_filtered (stream, "null");
else
fprintf_filtered (stream, "@%s", paddress (gdbarch, element));
things_printed++;
i += reps;
}
}
else
{
struct value *v = allocate_value (el_type);
struct value *next_v = allocate_value (el_type);
set_value_address (v, (address
+ get_java_object_header_size (gdbarch) + 4));
set_value_address (next_v, value_raw_address (v));
while (i < length && things_printed < options->print_max)
{
fputs_filtered (", ", stream);
wrap_here (n_spaces (2));
if (i > 0)
{
struct value *tmp;
tmp = next_v;
next_v = v;
v = tmp;
}
else
{
set_value_lazy (v, 1);
set_value_offset (v, 0);
}
set_value_offset (next_v, value_offset (v));
for (reps = 1; i + reps < length; reps++)
{
set_value_lazy (next_v, 1);
set_value_offset (next_v, value_offset (next_v) + TYPE_LENGTH (el_type));
if (memcmp (value_contents (v), value_contents (next_v),
TYPE_LENGTH (el_type)) != 0)
break;
}
if (reps == 1)
fprintf_filtered (stream, "%d: ", i);
else
fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);
opts = *options;
opts.deref_ref = 1;
common_val_print (v, stream, 1, &opts, current_language);
things_printed++;
i += reps;
}
}
if (i < length)
fprintf_filtered (stream, "...");
fprintf_filtered (stream, "}");
return 0;
}
/* If it's type String, print it */
if (TYPE_CODE (type) == TYPE_CODE_PTR
&& TYPE_TARGET_TYPE (type)
&& TYPE_TAG_NAME (TYPE_TARGET_TYPE (type))
&& strcmp (TYPE_TAG_NAME (TYPE_TARGET_TYPE (type)),
"java.lang.String") == 0
&& (options->format == 0 || options->format == 's')
&& address != 0
&& value_as_address (val) != 0)
{
struct type *char_type;
struct value *data_val;
CORE_ADDR data;
struct value *boffset_val;
unsigned long boffset;
struct value *count_val;
unsigned long count;
struct value *mark;
mark = value_mark (); /* Remember start of new values */
data_val = value_struct_elt (&val, NULL, "data", NULL, NULL);
data = value_as_address (data_val);
boffset_val = value_struct_elt (&val, NULL, "boffset", NULL, NULL);
boffset = value_as_address (boffset_val);
count_val = value_struct_elt (&val, NULL, "count", NULL, NULL);
count = value_as_address (count_val);
value_free_to_mark (mark); /* Release unnecessary values */
char_type = builtin_java_type (gdbarch)->builtin_char;
val_print_string (char_type, data + boffset, count, stream, options);
return 0;
}
opts = *options;
opts.deref_ref = 1;
return common_val_print (val, stream, 0, &opts, current_language);
}
int
m2_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)
{
unsigned int i = 0; /* Number of characters printed */
unsigned len;
struct type *elttype;
unsigned eltlen;
int length_pos, length_size, string_pos;
int char_size;
LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
elttype = check_typedef (TYPE_TARGET_TYPE (type));
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
if (prettyprint_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 requested, look for the first null char and only print
elements up to it. */
if (stop_print_at_null)
{
unsigned int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
(valaddr + embedded_offset)[temp_len]
&& temp_len < len && temp_len < print_max;
temp_len++);
len = temp_len;
}
LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0);
i = len;
}
else
{
fprintf_filtered (stream, "{");
val_print_array_elements (type, valaddr + embedded_offset,
address, stream, format, deref_ref,
recurse, pretty, 0);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
print_unpacked_pointer (type, address, address, format, stream);
break;
case TYPE_CODE_PTR:
if (TYPE_CONST (type))
print_variable_at_address (type, valaddr + embedded_offset,
stream, format, deref_ref, recurse,
pretty);
else if (format && format != 's')
print_scalar_formatted (valaddr + embedded_offset, type, format,
0, stream);
else
{
addr = unpack_pointer (type, valaddr + embedded_offset);
print_unpacked_pointer (type, addr, address, format, stream);
}
break;
case TYPE_CODE_MEMBER:
error (_("not implemented: member type in m2_val_print"));
break;
case TYPE_CODE_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (addressprint)
{
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
fputs_filtered (paddress (addr), 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, pretty);
}
else
fputs_filtered ("???", stream);
}
break;
case TYPE_CODE_UNION:
if (recurse && !unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
if (m2_is_long_set (type))
m2_print_long_set (type, valaddr, embedded_offset, address,
stream, format, pretty);
else
cp_print_value_fields (type, 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_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
fprintf_filtered (stream, "%ld)", (long int) val);
}
break;
case TYPE_CODE_RANGE:
if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
{
m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
address, stream, format, deref_ref, recurse, pretty);
break;
}
/* 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_METHOD:
break;
case TYPE_CODE_BITSTRING:
case TYPE_CODE_SET:
elttype = TYPE_INDEX_TYPE (type);
CHECK_TYPEDEF (elttype);
if (TYPE_STUB (elttype))
{
fprintf_filtered (stream, _("<incomplete type>"));
gdb_flush (stream);
break;
}
else
{
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);
i = get_discrete_bounds (range, &low_bound, &high_bound);
maybe_bad_bstring:
if (i < 0)
{
fputs_filtered (_("<error value>"), stream);
goto done;
}
for (i = low_bound; i <= high_bound; 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 (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))
{
int j = i;
fputs_filtered ("..", stream);
while (i + 1 <= high_bound
&& 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);
}
break;
case TYPE_CODE_VOID:
fprintf_filtered (stream, "void");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, _("<error type>"));
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, _("<incomplete type>"));
break;
default:
error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
}
gdb_flush (stream);
return (0);
}
int
c_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)
{
unsigned int i = 0; /* Number of characters printed */
unsigned len;
struct type *elttype;
unsigned eltlen;
LONGEST val;
CORE_ADDR addr;
int vector_int8s = 0;
int vector_floats = 0;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
if (prettyprint_arrays)
{
print_spaces_filtered (2 + 2 * recurse, stream);
}
/* APPLE LOCAL: gdb will print the int8_t elements of a vector
register as a string or as characters -- neither of which is
what the user expects 99% of the time. Instead, detect that
we're looking at a vector's int8_t array and treat it
specially. */
if (eltlen == 1
&& TYPE_VECTOR (type)
&& TYPE_CODE (elttype) == TYPE_CODE_INT
&& format == 0)
{
vector_int8s = 1;
}
/* APPLE LOCAL: Detect if we're about to print an array of
v4_float or v2_doubles in a vector register */
if ((eltlen == 4 || eltlen == 8)
&& TYPE_VECTOR (type)
&& TYPE_CODE (elttype) == TYPE_CODE_FLT)
{
vector_floats = 1;
}
/* 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')
&& vector_int8s == 0)
{
/* If requested, look for the first null char and only print
elements up to it. */
if (stop_print_at_null)
{
unsigned int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
(valaddr + embedded_offset)[temp_len]
&& temp_len < len && temp_len < print_max;
temp_len++);
len = temp_len;
}
LA_PRINT_STRING (stream, valaddr + embedded_offset, len, eltlen, 0);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members normally. */
if (cp_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, _("%d vtable entries"), len - 1);
}
else
{
i = 0;
}
/* If this is an array of int8_t's in a vector register,
force it to print as decimal by default, not as
decimal value + octal escaped char. */
if (format == 0 && vector_int8s)
format = 'd';
/* If this is an array of v4_float or v2_doubles in a vector
register, force it to print with the '%a' floating point hex
formatter when "p/x" is used. Default formatter remains the
'%g' style. */
if (format == 'x' && vector_floats)
format = 'A';
val_print_array_elements (type, valaddr + embedded_offset,
address, stream, format, deref_ref,
recurse, pretty, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
addr = address;
goto print_unpacked_pointer;
case TYPE_CODE_PTR:
if (format && format != 's')
{
print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
break;
}
if (vtblprint && cp_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.) */
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
print_function_pointer_address (addr, stream);
break;
}
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (elttype) == TYPE_CODE_METHOD)
{
cp_print_class_method (valaddr + embedded_offset, type, stream);
}
else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
{
cp_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:
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (addr, stream);
/* Return value is irrelevant except for string pointers. */
return (0);
}
if (addressprint && format != 's')
{
deprecated_print_address_numeric (addr, 1, stream);
}
/* For a pointer to char or unsigned char, also print the string
pointed to, unless pointer is null. */
/* FIXME: need to handle wchar_t here... */
if (TYPE_LENGTH (elttype) == 1
&& TYPE_CODE (elttype) == TYPE_CODE_INT
&& (format == 0 || format == 's')
&& addr != 0)
{
i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
}
else if (cp_is_vtbl_member (type))
{
/* print vtbl's nicely */
CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (vt_address);
if ((msymbol != NULL) &&
(vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (">", stream);
}
if (vt_address && vtblprint)
{
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);
}
}
}
/* 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 c_val_print"));
break;
case TYPE_CODE_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
{
cp_print_class_member (valaddr + embedded_offset,
TYPE_DOMAIN_TYPE (elttype),
stream, "");
break;
}
if (addressprint)
{
CORE_ADDR addr
= extract_typed_address (valaddr + embedded_offset, type);
fprintf_filtered (stream, "@");
deprecated_print_address_numeric (addr, 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, pretty);
}
else
fputs_filtered ("???", stream);
}
break;
case TYPE_CODE_UNION:
if (recurse && !unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
/*FIXME: Abstract this away */
if (vtblprint && cp_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.) */
int offset = (embedded_offset +
TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
CORE_ADDR addr
= extract_typed_address (valaddr + offset, field_type);
print_function_pointer_address (addr, stream);
}
else
cp_print_value_fields (type, 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_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
print_longest (stream, 'd', 0, val);
}
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);
/* C and C++ has no single byte int type, char is used instead.
Since we don't know whether the value is really intended to
be used as an integer or a character, print the character
equivalent as well. */
if (TYPE_LENGTH (type) == 1)
{
fputs_filtered (" ", stream);
LA_PRINT_CHAR ((unsigned char) unpack_long (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_METHOD:
{
struct value *v = value_at (type, address);
cp_print_class_method (value_contents (value_addr (v)),
lookup_pointer_type (type), stream);
break;
}
case TYPE_CODE_VOID:
fprintf_filtered (stream, "void");
break;
case TYPE_CODE_ERROR:
/* APPLE LOCAL display error as unknown type */
fprintf_filtered (stream, _("<unknown type>"));
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, _("<incomplete type>"));
break;
case TYPE_CODE_COMPLEX:
if (format)
print_scalar_formatted (valaddr + embedded_offset,
TYPE_TARGET_TYPE (type),
format, 0, stream);
else
print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
stream);
fprintf_filtered (stream, " + ");
if (format)
print_scalar_formatted (valaddr + embedded_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
TYPE_TARGET_TYPE (type),
format, 0, stream);
else
print_floating (valaddr + embedded_offset
+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
TYPE_TARGET_TYPE (type),
stream);
fprintf_filtered (stream, " * I");
break;
default:
error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type));
}
gdb_flush (stream);
return (0);
}
int
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)
{
unsigned int i = 0; /* Number of characters printed */
unsigned len;
struct type *elttype;
unsigned eltlen;
int length_pos, length_size, string_pos;
int char_size;
LONGEST val;
CORE_ADDR addr;
CHECK_TYPEDEF (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
elttype = check_typedef (TYPE_TARGET_TYPE (type));
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
if (prettyprint_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_pascal)
&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
&& (format == 0 || format == 's'))
{
/* If requested, look for the first null char and only print
elements up to it. */
if (stop_print_at_null)
{
unsigned int temp_len;
/* Look for a NULL char. */
for (temp_len = 0;
(valaddr + embedded_offset)[temp_len]
&& temp_len < len && temp_len < print_max;
temp_len++);
len = temp_len;
}
LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0);
i = len;
}
else
{
fprintf_filtered (stream, "{");
/* If this is a virtual function table, print the 0th
entry specially, and the rest of the members normally. */
if (pascal_object_is_vtbl_ptr_type (elttype))
{
i = 1;
fprintf_filtered (stream, "%d vtable entries", len - 1);
}
else
{
i = 0;
}
val_print_array_elements (type, valaddr + embedded_offset, address, stream,
format, deref_ref, recurse, pretty, i);
fprintf_filtered (stream, "}");
}
break;
}
/* Array of unspecified length: treat like pointer to first elt. */
addr = address;
goto print_unpacked_pointer;
case TYPE_CODE_PTR:
if (format && format != 's')
{
print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
break;
}
if (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.) */
/* Extract the address, assume that it is unsigned. */
print_address_demangle (extract_unsigned_integer (valaddr + embedded_offset, TYPE_LENGTH (type)),
stream, demangle);
break;
}
elttype = 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_FUNC)
{
/* 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 (addressprint && format != 's')
{
fputs_filtered (paddress (addr), stream);
}
/* 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)
&& (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);
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (vt_address);
if ((msymbol != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (">", stream);
}
if (vt_address && vtblprint)
{
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 (SYMBOL_LINKAGE_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);
}
}
}
/* 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_REF:
elttype = check_typedef (TYPE_TARGET_TYPE (type));
if (addressprint)
{
fprintf_filtered (stream, "@");
/* Extract the address, assume that it is unsigned. */
fputs_filtered (paddress (
extract_unsigned_integer (valaddr + embedded_offset,
gdbarch_ptr_bit (current_gdbarch) / HOST_CHAR_BIT)), 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);
}
break;
case TYPE_CODE_UNION:
if (recurse && !unionprint)
{
fprintf_filtered (stream, "{...}");
break;
}
/* Fall through. */
case TYPE_CODE_STRUCT:
if (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.) */
/* 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))),
stream, demangle);
}
else
{
if (is_pascal_string_type (type, &length_pos, &length_size,
&string_pos, &char_size, 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);
}
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);
}
}
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);
if (TYPE_STUB (elttype))
{
fprintf_filtered (stream, "<incomplete type>");
gdb_flush (stream);
break;
}
else
{
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);
i = get_discrete_bounds (range, &low_bound, &high_bound);
maybe_bad_bstring:
if (i < 0)
{
fputs_filtered ("<error value>", stream);
goto done;
}
for (i = low_bound; i <= high_bound; 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 (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))
{
int j = i;
fputs_filtered ("..", stream);
while (i + 1 <= high_bound
&& 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);
}
break;
case TYPE_CODE_VOID:
fprintf_filtered (stream, "void");
break;
case TYPE_CODE_ERROR:
fprintf_filtered (stream, "<error type>");
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, "<incomplete type>");
break;
default:
error (_("Invalid pascal type code %d in symbol table."), TYPE_CODE (type));
}
gdb_flush (stream);
return (0);
}
static void
ppscm_print_children (SCM printer, enum display_hint hint,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
struct gdbarch *gdbarch,
const struct language_defn *language,
int printed_nothing)
{
pretty_printer_worker_smob *w_smob
= (pretty_printer_worker_smob *) SCM_SMOB_DATA (printer);
int is_map, is_array, done_flag, pretty;
unsigned int i;
SCM children, status;
SCM iter = SCM_BOOL_F; /* -Wall */
struct cleanup *cleanups;
if (gdbscm_is_false (w_smob->children))
return;
if (!gdbscm_is_procedure (w_smob->children))
{
ppscm_print_pp_type_error
(_("pretty-printer \"children\" object is not a procedure or #f"),
w_smob->children);
return;
}
cleanups = make_cleanup (null_cleanup, NULL);
/* If we are printing a map or an array, we want special formatting. */
is_map = hint == HINT_MAP;
is_array = hint == HINT_ARRAY;
children = gdbscm_safe_call_1 (w_smob->children, printer,
gdbscm_memory_error_p);
if (gdbscm_is_exception (children))
{
ppscm_print_exception_unless_memory_error (children, stream);
goto done;
}
/* We combine two steps here: get children, make an iterator out of them.
This simplifies things because there's no language means of creating
iterators, and it's the printer object that knows how it will want its
children iterated over. */
if (!itscm_is_iterator (children))
{
ppscm_print_pp_type_error
(_("result of pretty-printer \"children\" procedure is not"
" a <gdb:iterator> object"), children);
goto done;
}
iter = children;
/* Use the prettyformat_arrays option if we are printing an array,
and the pretty option otherwise. */
if (is_array)
pretty = options->prettyformat_arrays;
else
{
if (options->prettyformat == Val_prettyformat)
pretty = 1;
else
pretty = options->prettyformat_structs;
}
done_flag = 0;
for (i = 0; i < options->print_max; ++i)
{
int rc;
SCM scm_name, v_scm;
char *name;
SCM item = itscm_safe_call_next_x (iter, gdbscm_memory_error_p);
struct cleanup *inner_cleanup = make_cleanup (null_cleanup, NULL);
if (gdbscm_is_exception (item))
{
ppscm_print_exception_unless_memory_error (item, stream);
break;
}
if (itscm_is_end_of_iteration (item))
{
/* Set a flag so we can know whether we printed all the
available elements. */
done_flag = 1;
break;
}
if (! scm_is_pair (item))
{
ppscm_print_pp_type_error
(_("result of pretty-printer children iterator is not a pair"
" or (end-of-iteration)"),
item);
continue;
}
scm_name = scm_car (item);
v_scm = scm_cdr (item);
if (!scm_is_string (scm_name))
{
ppscm_print_pp_type_error
(_("first element of pretty-printer children iterator is not"
" a string"), item);
continue;
}
name = gdbscm_scm_to_c_string (scm_name);
make_cleanup (xfree, name);
/* Print initial "{". For other elements, there are three cases:
1. Maps. Print a "," after each value element.
2. Arrays. Always print a ",".
3. Other. Always print a ",". */
if (i == 0)
{
if (printed_nothing)
fputs_filtered ("{", stream);
else
fputs_filtered (" = {", stream);
}
else if (! is_map || i % 2 == 0)
fputs_filtered (pretty ? "," : ", ", stream);
/* In summary mode, we just want to print "= {...}" if there is
a value. */
if (options->summary)
{
/* This increment tricks the post-loop logic to print what
we want. */
++i;
/* Likewise. */
pretty = 0;
break;
}
if (! is_map || i % 2 == 0)
{
if (pretty)
{
fputs_filtered ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
wrap_here (n_spaces (2 + 2 *recurse));
}
if (is_map && i % 2 == 0)
fputs_filtered ("[", stream);
else if (is_array)
{
/* We print the index, not whatever the child method
returned as the name. */
if (options->print_array_indexes)
fprintf_filtered (stream, "[%d] = ", i);
}
else if (! is_map)
{
fputs_filtered (name, stream);
fputs_filtered (" = ", stream);
}
if (lsscm_is_lazy_string (v_scm))
{
struct value_print_options local_opts = *options;
local_opts.addressprint = 0;
lsscm_val_print_lazy_string (v_scm, stream, &local_opts);
}
else if (scm_is_string (v_scm))
{
char *output = gdbscm_scm_to_c_string (v_scm);
fputs_filtered (output, stream);
xfree (output);
}
else
{
SCM except_scm;
struct value *value
= vlscm_convert_value_from_scheme (FUNC_NAME, GDBSCM_ARG_NONE,
v_scm, &except_scm,
gdbarch, language);
if (value == NULL)
{
ppscm_print_exception_unless_memory_error (except_scm, stream);
break;
}
common_val_print (value, stream, recurse + 1, options, language);
}
if (is_map && i % 2 == 0)
fputs_filtered ("] = ", stream);
do_cleanups (inner_cleanup);
}
if (i)
{
if (!done_flag)
{
if (pretty)
{
fputs_filtered ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
fputs_filtered ("...", stream);
}
if (pretty)
{
fputs_filtered ("\n", stream);
print_spaces_filtered (2 * recurse, stream);
}
fputs_filtered ("}", stream);
}
done:
do_cleanups (cleanups);
/* Play it safe, make sure ITER doesn't get GC'd. */
scm_remember_upto_here_1 (iter);
}
static void
list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
enum print_values values)
{
struct cleanup *old_chain;
struct ui_out *uiout = current_uiout;
struct ui_file *stb;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
gdb_assert (!arg->val || !arg->error);
gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
&& arg->error == NULL)
|| values == PRINT_SIMPLE_VALUES
|| (values == PRINT_ALL_VALUES
&& (arg->val != NULL || arg->error != NULL)));
gdb_assert (arg->entry_kind == print_entry_values_no
|| (arg->entry_kind == print_entry_values_only
&& (arg->val || arg->error)));
if (values != PRINT_NO_VALUES || what == all)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb);
if (arg->entry_kind == print_entry_values_only)
fputs_filtered ("@entry", stb);
ui_out_field_stream (uiout, "name", stb);
if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))
ui_out_field_int (uiout, "arg", 1);
if (values == PRINT_SIMPLE_VALUES)
{
check_typedef (arg->sym->type);
type_print (arg->sym->type, "", stb, -1);
ui_out_field_stream (uiout, "type", stb);
}
if (arg->val || arg->error)
{
volatile struct gdb_exception except;
if (arg->error)
except.message = arg->error;
else
{
/* TRY_CATCH has two statements, wrap it in a block. */
TRY_CATCH (except, RETURN_MASK_ERROR)
{
struct value_print_options opts;
get_raw_print_options (&opts);
opts.deref_ref = 1;
common_val_print (arg->val, stb, 0, &opts,
language_def (SYMBOL_LANGUAGE (arg->sym)));
}
}
if (except.message)
fprintf_filtered (stb, _("<error reading variable: %s>"),
except.message);
ui_out_field_stream (uiout, "value", stb);
}
do_cleanups (old_chain);
}
