void ada_print_typedef (struct type *type, struct symbol *new_symbol, struct ui_file *stream) { type = ada_check_typedef (type); ada_print_type (type, "", stream, 0, 0, &type_print_raw_options); fprintf_filtered (stream, "\n"); }
static void ada_varobj_decode_var (struct value **value_ptr, struct type **type_ptr) { if (*value_ptr) { *value_ptr = ada_get_decoded_value (*value_ptr); *type_ptr = ada_check_typedef (value_type (*value_ptr)); } else *type_ptr = ada_get_decoded_type (*type_ptr); }
void ada_value_print (struct value *val0, struct ui_file *stream, const struct value_print_options *options) { struct value *val = ada_to_fixed_value (val0); CORE_ADDR address = value_address (val); struct type *type = ada_check_typedef (value_enclosing_type (val)); struct value_print_options opts; /* If it is a pointer, indicate what it points to. */ if (TYPE_CODE (type) == TYPE_CODE_PTR) { /* Hack: don't print (char *) for char strings. Their type is indicated by the quoted string anyway. */ if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char) || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type))) { fprintf_filtered (stream, "("); type_print (type, "", stream, -1); fprintf_filtered (stream, ") "); } } else if (ada_is_array_descriptor_type (type)) { /* We do not print the type description unless TYPE is an array access type (this is encoded by the compiler as a typedef to a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */ if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) { fprintf_filtered (stream, "("); type_print (type, "", stream, -1); fprintf_filtered (stream, ") "); } } else if (ada_is_bogus_array_descriptor (type)) { fprintf_filtered (stream, "("); type_print (type, "", stream, -1); fprintf_filtered (stream, ") (...?)"); return; } opts = *options; opts.deref_ref = 1; val_print (type, value_embedded_offset (val), address, stream, 0, val, &opts, current_language); }
static void print_record (struct type *type, const gdb_byte *valaddr, struct ui_file *stream, int format, int recurse, enum val_prettyprint pretty) { type = ada_check_typedef (type); fprintf_filtered (stream, "("); if (print_field_values (type, valaddr, stream, format, recurse, pretty, 0, type, valaddr) != 0 && pretty) { fprintf_filtered (stream, "\n"); print_spaces_filtered (2 * recurse, stream); } fprintf_filtered (stream, ")"); }
void ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream) { unsigned int i; unsigned len; if (!type) { print_longest (stream, 'd', 0, val); return; } type = ada_check_typedef (type); switch (TYPE_CODE (type)) { case TYPE_CODE_ENUM: len = TYPE_NFIELDS (type); for (i = 0; i < len; i++) { if (TYPE_FIELD_ENUMVAL (type, i) == val) { break; } } if (i < len) { fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream); } else { print_longest (stream, 'd', 0, val); } break; case TYPE_CODE_INT: print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val); break; case TYPE_CODE_CHAR: LA_PRINT_CHAR (val, type, stream); break; case TYPE_CODE_BOOL: fprintf_filtered (stream, val ? "true" : "false"); break; case TYPE_CODE_RANGE: ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream); return; case TYPE_CODE_UNDEF: case TYPE_CODE_PTR: case TYPE_CODE_ARRAY: case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: case TYPE_CODE_FUNC: case TYPE_CODE_FLT: case TYPE_CODE_VOID: case TYPE_CODE_SET: case TYPE_CODE_STRING: case TYPE_CODE_ERROR: case TYPE_CODE_MEMBERPTR: case TYPE_CODE_METHODPTR: case TYPE_CODE_METHOD: case TYPE_CODE_REF: warning (_("internal error: unhandled type in ada_print_scalar")); break; default: error (_("Invalid type code in symbol table.")); } gdb_flush (stream); }
static void ada_val_print_1 (struct type *type, int offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options, const struct language_defn *language) { int offset_aligned; const gdb_byte *valaddr = value_contents_for_printing (original_value); type = ada_check_typedef (type); if (ada_is_array_descriptor_type (type) || (ada_is_constrained_packed_array_type (type) && TYPE_CODE (type) != TYPE_CODE_PTR)) { ada_val_print_gnat_array (type, valaddr, offset, address, stream, recurse, original_value, options, language); return; } offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr; type = printable_val_type (type, valaddr + offset_aligned); type = resolve_dynamic_type (type, valaddr + offset_aligned, address + offset_aligned); switch (TYPE_CODE (type)) { default: val_print (type, offset, address, stream, recurse, original_value, options, language_def (language_c)); break; case TYPE_CODE_PTR: ada_val_print_ptr (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options, language); break; case TYPE_CODE_INT: case TYPE_CODE_RANGE: ada_val_print_num (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options, language); break; case TYPE_CODE_ENUM: ada_val_print_enum (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options, language); break; case TYPE_CODE_FLT: ada_val_print_flt (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options, language); break; case TYPE_CODE_UNION: case TYPE_CODE_STRUCT: ada_val_print_struct_union (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options, language); break; case TYPE_CODE_ARRAY: ada_val_print_array (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options); return; case TYPE_CODE_REF: ada_val_print_ref (type, valaddr, offset, offset_aligned, address, stream, recurse, original_value, options, language); break; } }
void ada_print_type (struct type *type0, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags) { struct type *type = ada_check_typedef (ada_get_base_type (type0)); char *type_name = decoded_type_name (type0); int is_var_decl = (varstring != NULL && varstring[0] != '\0'); if (type == NULL) { if (is_var_decl) fprintf_filtered (stream, "%.*s: ", ada_name_prefix_len (varstring), varstring); fprintf_filtered (stream, "<null type?>"); return; } if (show > 0) type = ada_check_typedef (type); if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC) fprintf_filtered (stream, "%.*s: ", ada_name_prefix_len (varstring), varstring); if (type_name != NULL && show <= 0 && !ada_is_aligner_type (type)) { fprintf_filtered (stream, "%.*s", ada_name_prefix_len (type_name), type_name); return; } if (ada_is_aligner_type (type)) ada_print_type (ada_aligned_type (type), "", stream, show, level, flags); else if (ada_is_constrained_packed_array_type (type) && TYPE_CODE (type) != TYPE_CODE_PTR) print_array_type (type, stream, show, level, flags); else switch (TYPE_CODE (type)) { default: fprintf_filtered (stream, "<"); c_print_type (type, "", stream, show, level, flags); fprintf_filtered (stream, ">"); break; case TYPE_CODE_PTR: case TYPE_CODE_TYPEDEF: fprintf_filtered (stream, "access "); ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags); break; case TYPE_CODE_REF: fprintf_filtered (stream, "<ref> "); ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags); break; case TYPE_CODE_ARRAY: print_array_type (type, stream, show, level, flags); break; case TYPE_CODE_BOOL: fprintf_filtered (stream, "(false, true)"); break; case TYPE_CODE_INT: if (ada_is_fixed_point_type (type)) print_fixed_point_type (type, stream); else { const char *name = ada_type_name (type); if (!ada_is_range_type_name (name)) fprintf_filtered (stream, _("<%d-byte integer>"), TYPE_LENGTH (type)); else { fprintf_filtered (stream, "range "); print_range_type (type, stream); } } break; case TYPE_CODE_RANGE: if (ada_is_fixed_point_type (type)) print_fixed_point_type (type, stream); else if (ada_is_modular_type (type)) fprintf_filtered (stream, "mod %s", int_string (ada_modulus (type), 10, 0, 0, 1)); else { fprintf_filtered (stream, "range "); print_range (type, stream); } break; case TYPE_CODE_FLT: fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type)); break; case TYPE_CODE_ENUM: if (show < 0) fprintf_filtered (stream, "(...)"); else print_enum_type (type, stream); break; case TYPE_CODE_STRUCT: if (ada_is_array_descriptor_type (type)) print_array_type (type, stream, show, level, flags); else if (ada_is_bogus_array_descriptor (type)) fprintf_filtered (stream, _("array (?) of ? (<mal-formed descriptor>)")); else print_record_type (type, stream, show, level, flags); break; case TYPE_CODE_UNION: print_unchecked_union_type (type, stream, show, level, flags); break; case TYPE_CODE_FUNC: print_func_type (type, stream, varstring, flags); break; } }
static int ada_val_print_1 (struct type *type, const gdb_byte *valaddr0, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int format, int deref_ref, int recurse, enum val_prettyprint pretty) { unsigned int len; int i; struct type *elttype; unsigned int eltlen; LONGEST val; const gdb_byte *valaddr = valaddr0 + embedded_offset; type = ada_check_typedef (type); if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type)) { int retn; struct value *mark = value_mark (); struct value *val; val = value_from_contents_and_address (type, valaddr, address); val = ada_coerce_to_simple_array_ptr (val); if (val == NULL) { fprintf_filtered (stream, "(null)"); retn = 0; } else retn = ada_val_print_1 (value_type (val), value_contents (val), 0, VALUE_ADDRESS (val), stream, format, deref_ref, recurse, pretty); value_free_to_mark (mark); return retn; } valaddr = ada_aligned_value_addr (type, valaddr); embedded_offset -= valaddr - valaddr0 - embedded_offset; type = printable_val_type (type, valaddr); switch (TYPE_CODE (type)) { default: return c_val_print (type, valaddr0, embedded_offset, address, stream, format, deref_ref, recurse, pretty); case TYPE_CODE_PTR: { int ret = c_val_print (type, valaddr0, embedded_offset, address, stream, format, deref_ref, recurse, pretty); if (ada_is_tag_type (type)) { struct value *val = value_from_contents_and_address (type, valaddr, address); const char *name = ada_tag_name (val); if (name != NULL) fprintf_filtered (stream, " (%s)", name); return 0; } return ret; } case TYPE_CODE_INT: case TYPE_CODE_RANGE: if (ada_is_fixed_point_type (type)) { LONGEST v = unpack_long (type, valaddr); int len = TYPE_LENGTH (type); fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g", (double) ada_fixed_to_float (type, v)); return 0; } else if (ada_is_vax_floating_type (type)) { struct value *val = value_from_contents_and_address (type, valaddr, address); struct value *func = ada_vax_float_print_function (type); if (func != 0) { static struct type *parray_of_char = NULL; struct value *printable_val; if (parray_of_char == NULL) parray_of_char = make_pointer_type (create_array_type (NULL, builtin_type_char, create_range_type (NULL, builtin_type_int, 0, 32)), NULL); printable_val = value_ind (value_cast (parray_of_char, call_function_by_hand (func, 1, &val))); fprintf_filtered (stream, "%s", value_contents (printable_val)); return 0; } /* No special printing function. Do as best we can. */ } else if (TYPE_CODE (type) == TYPE_CODE_RANGE) { struct type *target_type = TYPE_TARGET_TYPE (type); if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type)) { /* Obscure case of range type that has different length from its base type. Perform a conversion, or we will get a nonsense value. Actually, we could use the same code regardless of lengths; I'm just avoiding a cast. */ struct value *v = value_cast (target_type, value_from_contents_and_address (type, valaddr, 0)); return ada_val_print_1 (target_type, value_contents (v), 0, 0, stream, format, 0, recurse + 1, pretty); } else return ada_val_print_1 (TYPE_TARGET_TYPE (type), valaddr0, embedded_offset, address, stream, format, deref_ref, recurse, pretty); } else { format = format ? format : output_format; if (format) { print_scalar_formatted (valaddr, type, format, 0, stream); } else if (ada_is_system_address_type (type)) { /* FIXME: We want to print System.Address variables using the same format as for any access type. But for some reason GNAT encodes the System.Address type as an int, so we have to work-around this deficiency by handling System.Address values as a special case. */ fprintf_filtered (stream, "("); type_print (type, "", stream, -1); fprintf_filtered (stream, ") "); fputs_filtered (paddress (extract_typed_address (valaddr, builtin_type_void_data_ptr)), stream); } else { val_print_type_code_int (type, valaddr, stream); if (ada_is_character_type (type)) { fputs_filtered (" ", stream); ada_printchar ((unsigned char) unpack_long (type, valaddr), stream); } } return 0; } case TYPE_CODE_ENUM: if (format) { print_scalar_formatted (valaddr, type, format, 0, stream); break; } len = TYPE_NFIELDS (type); val = unpack_long (type, valaddr); for (i = 0; i < len; i++) { QUIT; if (val == TYPE_FIELD_BITPOS (type, i)) { break; } } if (i < len) { const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i)); if (name[0] == '\'') fprintf_filtered (stream, "%ld %s", (long) val, name); else fputs_filtered (name, stream); } else { print_longest (stream, 'd', 0, val); } break; case TYPE_CODE_FLAGS: if (format) print_scalar_formatted (valaddr, type, format, 0, stream); else val_print_type_code_flags (type, valaddr, stream); break; case TYPE_CODE_FLT: if (format) return c_val_print (type, valaddr0, embedded_offset, address, stream, format, deref_ref, recurse, pretty); else ada_print_floating (valaddr0 + embedded_offset, type, stream); break; case TYPE_CODE_UNION: case TYPE_CODE_STRUCT: if (ada_is_bogus_array_descriptor (type)) { fprintf_filtered (stream, "(...?)"); return 0; } else { print_record (type, valaddr, stream, format, recurse, pretty); return 0; } case TYPE_CODE_ARRAY: elttype = TYPE_TARGET_TYPE (type); if (elttype == NULL) eltlen = 0; else eltlen = TYPE_LENGTH (elttype); /* FIXME: This doesn't deal with non-empty arrays of 0-length items (not a typical case!) */ if (eltlen == 0) len = 0; else len = TYPE_LENGTH (type) / eltlen; /* For an array of chars, print with string syntax. */ if (ada_is_string_type (type) && (format == 0 || format == 's')) { if (prettyprint_arrays) { print_spaces_filtered (2 + 2 * recurse, stream); } /* If requested, look for the first null char and only print elements up to it. */ if (stop_print_at_null) { int temp_len; /* Look for a NULL char. */ for (temp_len = 0; temp_len < len && temp_len < print_max && char_at (valaddr, temp_len, eltlen) != 0; temp_len += 1); len = temp_len; } printstr (stream, valaddr, len, 0, eltlen); } else { len = 0; fprintf_filtered (stream, "("); print_optional_low_bound (stream, type); if (TYPE_FIELD_BITSIZE (type, 0) > 0) val_print_packed_array_elements (type, valaddr, 0, stream, format, recurse, pretty); else val_print_array_elements (type, valaddr, address, stream, format, deref_ref, recurse, pretty, 0); fprintf_filtered (stream, ")"); } gdb_flush (stream); return len; case TYPE_CODE_REF: /* 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. */ elttype = check_typedef (TYPE_TARGET_TYPE (type)); if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) { LONGEST deref_val_int = (LONGEST) unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr); if (deref_val_int != 0) { struct value *deref_val = ada_value_ind (value_from_longest (lookup_pointer_type (elttype), deref_val_int)); val_print (value_type (deref_val), value_contents (deref_val), 0, VALUE_ADDRESS (deref_val), stream, format, deref_ref, recurse + 1, pretty); } else fputs_filtered ("(null)", stream); } else fputs_filtered ("???", stream); break; } gdb_flush (stream); return 0; }