Extract string-printing out of ada_val_print_array

This patch creates a new function called "ada_val_print_string"
whose code is directly extracted out of ada_val_print_array.
The extracted code is then replaced by a call to this new function,
followed by a "return". The return avoids the need for an "else"
branch, with the associated block nesting. The latter is not really
terrible in this case, but it seems more readable this way.

gdb/ChangeLog:

        * ada-valprint.c (ada_val_print_string): New function,
        extracted from ada_val_print_array.
        (ada_val_print_array): Replace extracted code by call
        to ada_val_print_string followed by a return.  Move
        "else" branch to the function's top block.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 004709b755057f2e6809b91ecf5c4f1c2827fd13..e66861774e5b70587998dc67140690723000c7fa 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,11 @@
+2014-01-07  Joel Brobecker  <brobecker@adacore.com>
+
+       * ada-valprint.c (ada_val_print_string): New function,
+       extracted from ada_val_print_array.
+       (ada_val_print_array): Replace extracted code by call
+       to ada_val_print_string followed by a return.  Move
+       "else" branch to the function's top block.
+
 2014-01-07  Joel Brobecker  <brobecker@adacore.com>
 
        * ada-valprint.c (ada_val_print_array): Move implementation

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 43e1490d41cbe8e3d80f68687adf1e285c7bea32..d1c855324ecab01beaf86b8580a3d6029c4f3f93 100644 (file)
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -685,6 +685,54 @@ print_field_values (struct type *type, const gdb_byte *valaddr,
   return comma_needed;
 }
 
+/* Implement Ada val_print'ing for the case where TYPE is
+   a TYPE_CODE_ARRAY of characters.  */
+
+static void
+ada_val_print_string (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)
+{
+  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
+  struct type *elttype = TYPE_TARGET_TYPE (type);
+  unsigned int eltlen;
+  unsigned int len;
+
+  /* We know that ELTTYPE cannot possibly be null, because we assume
+     that we're called only when TYPE is a string-like type.
+     Similarly, the size of ELTTYPE should also be non-null, since
+     it's a character-like type.  */
+  gdb_assert (elttype != NULL);
+  gdb_assert (TYPE_LENGTH (elttype) != 0);
+
+  eltlen = TYPE_LENGTH (elttype);
+  len = TYPE_LENGTH (type) / eltlen;
+
+  if (options->prettyformat_arrays)
+    print_spaces_filtered (2 + 2 * recurse, stream);
+
+  /* If requested, look for the first null char and only print
+     elements up to it.  */
+  if (options->stop_print_at_null)
+    {
+      int temp_len;
+
+      /* Look for a NULL char.  */
+      for (temp_len = 0;
+          (temp_len < len
+           && temp_len < options->print_max
+           && char_at (valaddr + offset_aligned,
+                       temp_len, eltlen, byte_order) != 0);
+          temp_len += 1);
+      len = temp_len;
+    }
+
+  printstr (stream, elttype, valaddr + offset_aligned, len, 0,
+           eltlen, options);
+}
+
 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
    thin pointers, etc).  */
 
@@ -943,60 +991,27 @@ ada_val_print_array (struct type *type, const gdb_byte *valaddr,
                     const struct value *original_value,
                     const struct value_print_options *options)
 {
-  /* For an array of chars, print with string syntax.  */
+  /* For an array of characters, print with string syntax.  */
   if (ada_is_string_type (type)
       && (options->format == 0 || options->format == 's'))
     {
-      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
-      struct type *elttype = TYPE_TARGET_TYPE (type);
-      unsigned int eltlen;
-      unsigned int len;
-
-      /* We know that ELTTYPE cannot possibly be null, because we found
-        that TYPE is a string-like type.  Similarly, the size of ELTTYPE
-        should also be non-null, since it's a character-like type.  */
-      gdb_assert (elttype != NULL);
-      gdb_assert (TYPE_LENGTH (elttype) != 0);
-
-      eltlen = TYPE_LENGTH (elttype);
-      len = TYPE_LENGTH (type) / eltlen;
-
-      if (options->prettyformat_arrays)
-        print_spaces_filtered (2 + 2 * recurse, stream);
-
-      /* If requested, look for the first null char and only print
-         elements up to it.  */
-      if (options->stop_print_at_null)
-        {
-          int temp_len;
-
-          /* Look for a NULL char.  */
-          for (temp_len = 0;
-               (temp_len < len
-                && temp_len < options->print_max
-                && char_at (valaddr + offset_aligned,
-                           temp_len, eltlen, byte_order) != 0);
-               temp_len += 1);
-          len = temp_len;
-        }
-
-      printstr (stream, elttype, valaddr + offset_aligned, len, 0,
-               eltlen, options);
+      ada_val_print_string (type, valaddr, offset, offset_aligned,
+                           address, stream, recurse, original_value,
+                           options);
+      return;
     }
+
+  fprintf_filtered (stream, "(");
+  print_optional_low_bound (stream, type, options);
+  if (TYPE_FIELD_BITSIZE (type, 0) > 0)
+    val_print_packed_array_elements (type, valaddr, offset_aligned,
+                                    0, stream, recurse,
+                                    original_value, options);
   else
-    {
-      fprintf_filtered (stream, "(");
-      print_optional_low_bound (stream, type, options);
-      if (TYPE_FIELD_BITSIZE (type, 0) > 0)
-        val_print_packed_array_elements (type, valaddr, offset_aligned,
-                                        0, stream, recurse,
-                                        original_value, options);
-      else
-        val_print_array_elements (type, valaddr, offset_aligned, address,
-                                 stream, recurse, original_value,
-                                 options, 0);
-      fprintf_filtered (stream, ")");
-    }
+    val_print_array_elements (type, valaddr, offset_aligned, address,
+                             stream, recurse, original_value,
+                             options, 0);
+  fprintf_filtered (stream, ")");
 }
 
 /* Implement Ada val_print'ing for the case where TYPE is