[gdb/testsuite] Accept new complex print style in mixed-lang-stack.exp

[deliverable/binutils-gdb.git] / gdb / f-valprint.c

diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index bbc09cd56065fcf7b306fae589a911cb1bd41008..36328c796ca3e58ff1b893a581dc081bf13c75e6 100644 (file)
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -208,38 +208,35 @@ static const struct generic_val_print_decorations f_decorations =
   "}"
 };
 
-/* See val_print for a description of the various parameters of this
-   function; they are identical.  */
+/* See f-lang.h.  */
 
 void
-f_val_print (struct type *type, int embedded_offset,
-            CORE_ADDR address, struct ui_file *stream, int recurse,
-            struct value *original_value,
-            const struct value_print_options *options)
+f_value_print_innner (struct value *val, struct ui_file *stream, int recurse,
+                     const struct value_print_options *options)
 {
+  struct type *type = check_typedef (value_type (val));
   struct gdbarch *gdbarch = get_type_arch (type);
   int printed_field = 0; /* Number of fields printed.  */
   struct type *elttype;
   CORE_ADDR addr;
   int index;
-  const gdb_byte *valaddr =value_contents_for_printing (original_value);
+  const gdb_byte *valaddr = value_contents_for_printing (val);
+  const CORE_ADDR address = value_address (val);
 
-  type = 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 + embedded_offset,
-                      TYPE_LENGTH (type), NULL, 0, options);
+                      valaddr, TYPE_LENGTH (type), NULL, 0, options);
       break;
 
     case TYPE_CODE_ARRAY:
       if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_CHAR)
        {
          fprintf_filtered (stream, "(");
-         f77_print_array (type, valaddr, embedded_offset,
-                          address, stream, recurse, original_value, options);
+         f77_print_array (type, valaddr, 0,
+                          address, stream, recurse, val, options);
          fprintf_filtered (stream, ")");
        }
       else
@@ -247,8 +244,7 @@ f_val_print (struct type *type, int embedded_offset,
          struct type *ch_type = TYPE_TARGET_TYPE (type);
 
          f77_get_dynamic_length_of_aggregate (type);
-         LA_PRINT_STRING (stream, ch_type,
-                          valaddr + embedded_offset,
+         LA_PRINT_STRING (stream, ch_type, valaddr,
                           TYPE_LENGTH (type) / TYPE_LENGTH (ch_type),
                           NULL, 0, options);
        }
@@ -257,15 +253,14 @@ f_val_print (struct type *type, int embedded_offset,
     case TYPE_CODE_PTR:
       if (options->format && options->format != 's')
        {
-         val_print_scalar_formatted (type, embedded_offset,
-                                     original_value, options, 0, stream);
+         value_print_scalar_formatted (val, options, 0, stream);
          break;
        }
       else
        {
          int want_space = 0;
 
-         addr = unpack_pointer (type, valaddr + embedded_offset);
+         addr = unpack_pointer (type, valaddr);
          elttype = check_typedef (TYPE_TARGET_TYPE (type));
 
          if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
@@ -307,12 +302,10 @@ f_val_print (struct type *type, int embedded_offset,
 
          opts.format = (options->format ? options->format
                         : options->output_format);
-         val_print_scalar_formatted (type, embedded_offset,
-                                     original_value, &opts, 0, stream);
+         value_print_scalar_formatted (val, &opts, 0, stream);
        }
       else
-       val_print_scalar_formatted (type, embedded_offset,
-                                   original_value, options, 0, stream);
+       value_print_scalar_formatted (val, options, 0, stream);
       break;
 
     case TYPE_CODE_STRUCT:
@@ -322,8 +315,7 @@ f_val_print (struct type *type, int embedded_offset,
       fprintf_filtered (stream, "( ");
       for (index = 0; index < TYPE_NFIELDS (type); index++)
         {
-         struct value *field = value_field
-           ((struct value *)original_value, index);
+         struct value *field = value_field (val, index);
 
          struct type *field_type = check_typedef (TYPE_FIELD_TYPE (type, index));
 
@@ -358,18 +350,15 @@ f_val_print (struct type *type, int embedded_offset,
          struct value_print_options opts = *options;
          opts.format = (options->format ? options->format
                         : options->output_format);
-         val_print_scalar_formatted (type, embedded_offset,
-                                     original_value, &opts, 0, stream);
+         value_print_scalar_formatted (val, &opts, 0, stream);
        }
       else
        {
-         int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
-         LONGEST val
-           = unpack_long (type, valaddr + embedded_offset * unit_size);
+         LONGEST longval = value_as_long (val);
          /* The Fortran standard doesn't specify how logical types are
             represented.  Different compilers use different non zero
             values to represent logical true.  */
-         if (val == 0)
+         if (longval == 0)
            fputs_filtered (f_decorations.false_name, stream);
          else
            fputs_filtered (f_decorations.true_name, stream);
@@ -387,9 +376,7 @@ f_val_print (struct type *type, int embedded_offset,
     case TYPE_CODE_COMPLEX:
     case TYPE_CODE_CHAR:
     default:
-      generic_val_print (type, embedded_offset, address,
-                        stream, recurse, original_value, options,
-                        &f_decorations);
+      generic_value_print (val, stream, recurse, options, &f_decorations);
       break;
     }
 }