X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fada-typeprint.c;h=70fad1c3268b341102be8000a18f668b90c43077;hb=2365f8d70c50afbfd6be69a4076ea6e78fb5485d;hp=5599278daa4e1449c3be3a1ab7c58b721c913948;hpb=0d5cff5020224cfd67bc3d6e30b158105d03a324;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/ada-typeprint.c b/gdb/ada-typeprint.c
index 5599278daa..70fad1c326 100644
--- a/gdb/ada-typeprint.c
+++ b/gdb/ada-typeprint.c
@@ -1,6 +1,5 @@
 /* Support for printing Ada types for GDB, the GNU debugger.
-   Copyright (C) 1986, 1988-1989, 1991, 1997-2004, 2007-2012 Free
-   Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -18,48 +17,24 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-#include "gdb_obstack.h"
 #include "bfd.h"		/* Binary File Description */
-#include "symtab.h"
 #include "gdbtypes.h"
-#include "expression.h"
 #include "value.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "command.h"
-#include "gdbcmd.h"
-#include "language.h"
-#include "demangle.h"
 #include "c-lang.h"
+#include "cli/cli-style.h"
 #include "typeprint.h"
+#include "target-float.h"
 #include "ada-lang.h"
-
 #include <ctype.h>
-#include "gdb_string.h"
-#include <errno.h>
 
 static int print_selected_record_field_types (struct type *, struct type *,
 					      int, int,
-					      struct ui_file *, int, int);
-   
-static int print_record_field_types (struct type *, struct type *,
-				     struct ui_file *, int, int);
-
-static void print_array_type (struct type *, struct ui_file *, int, int);
-
-static int print_choices (struct type *, int, struct ui_file *,
-			  struct type *);
-
-static void print_range (struct type *, struct ui_file *);
+					      struct ui_file *, int, int,
+					      const struct type_print_options *);
 
-static void print_range_bound (struct type *, char *, int *,
-			       struct ui_file *);
-
-static void
-print_dynamic_range_bound (struct type *, const char *, int,
-			   const char *, struct ui_file *);
-
-static void print_range_type (struct type *, struct ui_file *);
+static int print_record_field_types (struct type *, struct type *,
+				     struct ui_file *, int, int,
+				     const struct type_print_options *);
 
 
 
@@ -82,7 +57,7 @@ decoded_type_name (struct type *type)
       if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
 	{
 	  name_buffer_len = 16 + 2 * strlen (raw_name);
-	  name_buffer = xrealloc (name_buffer, name_buffer_len);
+	  name_buffer = (char *) xrealloc (name_buffer, name_buffer_len);
 	}
       strcpy (name_buffer, raw_name);
 
@@ -118,25 +93,89 @@ decoded_type_name (struct type *type)
     }
 }
 
-/* Print TYPE on STREAM, preferably as a range.  */
+/* Return nonzero if TYPE is a subrange type, and its bounds
+   are identical to the bounds of its subtype.  */
+
+static int
+type_is_full_subrange_of_target_type (struct type *type)
+{
+  struct type *subtype;
+
+  if (TYPE_CODE (type) != TYPE_CODE_RANGE)
+    return 0;
+
+  subtype = TYPE_TARGET_TYPE (type);
+  if (subtype == NULL)
+    return 0;
+
+  if (is_dynamic_type (type))
+    return 0;
+
+  if (ada_discrete_type_low_bound (type)
+      != ada_discrete_type_low_bound (subtype))
+    return 0;
+
+  if (ada_discrete_type_high_bound (type)
+      != ada_discrete_type_high_bound (subtype))
+    return 0;
+
+  return 1;
+}
+
+/* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
+   is nonzero.  */
 
 static void
-print_range (struct type *type, struct ui_file *stream)
+print_range (struct type *type, struct ui_file *stream,
+	     int bounds_prefered_p)
 {
+  if (!bounds_prefered_p)
+    {
+      /* Try stripping all TYPE_CODE_RANGE layers whose bounds
+	 are identical to the bounds of their subtype.  When
+	 the bounds of both types match, it can allow us to
+	 print a range using the name of its base type, which
+	 is easier to read.  For instance, we would print...
+
+	     array (character) of ...
+
+	 ... instead of...
+
+	     array ('["00"]' .. '["ff"]') of ...  */
+      while (type_is_full_subrange_of_target_type (type))
+	type = TYPE_TARGET_TYPE (type);
+    }
+
   switch (TYPE_CODE (type))
     {
     case TYPE_CODE_RANGE:
     case TYPE_CODE_ENUM:
       {
-	struct type *target_type;
-	target_type = TYPE_TARGET_TYPE (type);
-	if (target_type == NULL)
-	  target_type = type;
-	ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
-			  stream);
-	fprintf_filtered (stream, " .. ");
-	ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
-			  stream);
+	LONGEST lo = 0, hi = 0; /* init for gcc -Wall */
+	int got_error = 0;
+
+	try
+	  {
+	    lo = ada_discrete_type_low_bound (type);
+	    hi = ada_discrete_type_high_bound (type);
+	  }
+	catch (const gdb_exception_error &e)
+	  {
+	    /* This can happen when the range is dynamic.  Sometimes,
+	       resolving dynamic property values requires us to have
+	       access to an actual object, which is not available
+	       when the user is using the "ptype" command on a type.
+	       Print the range as an unbounded range.  */
+	    fprintf_filtered (stream, "<>");
+	    got_error = 1;
+	  }
+
+	if (!got_error)
+	  {
+	    ada_print_scalar (type, lo, stream);
+	    fprintf_filtered (stream, " .. ");
+	    ada_print_scalar (type, hi, stream);
+	  }
       }
       break;
     default:
@@ -151,7 +190,7 @@ print_range (struct type *type, struct ui_file *stream)
    set *N past the bound and its delimiter, if any.  */
 
 static void
-print_range_bound (struct type *type, char *bounds, int *n,
+print_range_bound (struct type *type, const char *bounds, int *n,
 		   struct ui_file *stream)
 {
   LONGEST B;
@@ -178,8 +217,8 @@ print_range_bound (struct type *type, char *bounds, int *n,
   else
     {
       int bound_len;
-      char *bound = bounds + *n;
-      char *pend;
+      const char *bound = bounds + *n;
+      const char *pend;
 
       pend = strstr (bound, "__");
       if (pend == NULL)
@@ -201,27 +240,27 @@ static void
 print_dynamic_range_bound (struct type *type, const char *name, int name_len,
 			   const char *suffix, struct ui_file *stream)
 {
-  static char *name_buf = NULL;
-  static size_t name_buf_len = 0;
   LONGEST B;
-  int OK;
+  std::string name_buf (name, name_len);
+  name_buf += suffix;
 
-  GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
-  strncpy (name_buf, name, name_len);
-  strcpy (name_buf + name_len, suffix);
-
-  B = get_int_var_value (name_buf, &OK);
-  if (OK)
+  if (get_int_var_value (name_buf.c_str (), B))
     ada_print_scalar (type, B, stream);
   else
     fprintf_filtered (stream, "?");
 }
 
 /* Print RAW_TYPE as a range type, using any bound information
-   following the GNAT encoding (if available).  */
+   following the GNAT encoding (if available).
+
+   If BOUNDS_PREFERED_P is nonzero, force the printing of the range
+   using its bounds.  Otherwise, try printing the range without
+   printing the value of the bounds, if possible (this is only
+   considered a hint, not a guaranty).  */
 
 static void
-print_range_type (struct type *raw_type, struct ui_file *stream)
+print_range_type (struct type *raw_type, struct ui_file *stream,
+		  int bounds_prefered_p)
 {
   const char *name;
   struct type *base_type;
@@ -238,11 +277,11 @@ print_range_type (struct type *raw_type, struct ui_file *stream)
 
   subtype_info = strstr (name, "___XD");
   if (subtype_info == NULL)
-    print_range (raw_type, stream);
+    print_range (raw_type, stream, bounds_prefered_p);
   else
     {
       int prefix_len = subtype_info - name;
-      char *bounds_str;
+      const char *bounds_str;
       int n;
 
       subtype_info += 5;
@@ -274,7 +313,8 @@ static void
 print_enum_type (struct type *type, struct ui_file *stream)
 {
   int len = TYPE_NFIELDS (type);
-  int i, lastval;
+  int i;
+  LONGEST lastval;
 
   fprintf_filtered (stream, "(");
   wrap_here (" ");
@@ -287,10 +327,11 @@ print_enum_type (struct type *type, struct ui_file *stream)
 	fprintf_filtered (stream, ", ");
       wrap_here ("    ");
       fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
-      if (lastval != TYPE_FIELD_BITPOS (type, i))
+      if (lastval != TYPE_FIELD_ENUMVAL (type, i))
 	{
-	  fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
-	  lastval = TYPE_FIELD_BITPOS (type, i);
+	  fprintf_filtered (stream, " => %s",
+			    plongest (TYPE_FIELD_ENUMVAL (type, i)));
+	  lastval = TYPE_FIELD_ENUMVAL (type, i);
 	}
       lastval += 1;
     }
@@ -302,16 +343,23 @@ print_enum_type (struct type *type, struct ui_file *stream)
 static void
 print_fixed_point_type (struct type *type, struct ui_file *stream)
 {
-  DOUBLEST delta = ada_delta (type);
-  DOUBLEST small = ada_fixed_to_float (type, 1.0);
+  struct value *delta = ada_delta (type);
+  struct value *small = ada_scaling_factor (type);
 
-  if (delta < 0.0)
+  if (delta == nullptr)
     fprintf_filtered (stream, "delta ??");
   else
     {
-      fprintf_filtered (stream, "delta %g", (double) delta);
-      if (delta != small)
-	fprintf_filtered (stream, " <'small = %g>", (double) small);
+      std::string str;
+      str = target_float_to_string (value_contents (delta),
+				    value_type (delta), "%g");
+      fprintf_filtered (stream, "delta %s", str.c_str());
+      if (!value_equal (delta, small))
+	{
+	  str = target_float_to_string (value_contents (small),
+					value_type (small), "%g");
+	  fprintf_filtered (stream, " <'small = %s>", str.c_str());
+	}
     }
 }
 
@@ -322,10 +370,11 @@ print_fixed_point_type (struct type *type, struct ui_file *stream)
 
 static void
 print_array_type (struct type *type, struct ui_file *stream, int show,
-		  int level)
+		  int level, const struct type_print_options *flags)
 {
   int bitsize;
   int n_indices;
+  struct type *elt_type = NULL;
 
   if (ada_is_constrained_packed_array_type (type))
     type = ada_coerce_to_simple_array_type (type);
@@ -335,7 +384,8 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
 
   if (type == NULL)
     {
-      fprintf_filtered (stream, _("<undecipherable array type>"));
+      fprintf_styled (stream, metadata_style.style (),
+		      _("<undecipherable array type>"));
       return;
     }
 
@@ -356,7 +406,8 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
 	    {
 	      if (arr_type != type)
 		fprintf_filtered (stream, ", ");
-	      print_range (TYPE_INDEX_TYPE (arr_type), stream);
+	      print_range (TYPE_INDEX_TYPE (arr_type), stream,
+			   0 /* bounds_prefered_p */);
 	      if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 		bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 	    }
@@ -373,7 +424,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
 	      if (k > 0)
 		fprintf_filtered (stream, ", ");
 	      print_range_type (TYPE_FIELD_TYPE (range_desc_type, k),
-				stream);
+				stream, 0 /* bounds_prefered_p */);
 	      if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 		bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 	    }
@@ -387,11 +438,15 @@ print_array_type (struct type *type, struct ui_file *stream, int show,
 	fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
     }
 
+  elt_type = ada_array_element_type (type, n_indices);
   fprintf_filtered (stream, ") of ");
   wrap_here ("");
-  ada_print_type (ada_array_element_type (type, n_indices), "", stream,
-		  show == 0 ? 0 : show - 1, level + 1);
-  if (bitsize > 0)
+  ada_print_type (elt_type, "", stream, show == 0 ? 0 : show - 1, level + 1,
+		  flags);
+  /* Arrays with variable-length elements are never bit-packed in practice but
+     compilers have to describe their stride so that we can properly fetch
+     individual elements.  Do not say the array is packed in this case.  */
+  if (bitsize > 0 && !is_dynamic_type (elt_type))
     fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
 }
 
@@ -471,7 +526,7 @@ print_choices (struct type *type, int field_num, struct ui_file *stream,
     }
 
 Huh:
-  fprintf_filtered (stream, "?? =>");
+  fprintf_filtered (stream, "? =>");
   return 0;
 }
 
@@ -486,7 +541,8 @@ Huh:
 static void
 print_variant_clauses (struct type *type, int field_num,
 		       struct type *outer_type, struct ui_file *stream,
-		       int show, int level)
+		       int show, int level,
+		       const struct type_print_options *flags)
 {
   int i;
   struct type *var_type, *par_type;
@@ -512,13 +568,14 @@ print_variant_clauses (struct type *type, int field_num,
       if (print_choices (var_type, i, stream, discr_type))
 	{
 	  if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
-					outer_type, stream, show, level + 4) 
+					outer_type, stream, show, level + 4,
+					flags)
 	      <= 0)
 	    fprintf_filtered (stream, " null;");
 	}
       else
 	print_selected_record_field_types (var_type, outer_type, i, i,
-					   stream, show, level + 4);
+					   stream, show, level + 4, flags);
     }
 }
 
@@ -532,13 +589,17 @@ print_variant_clauses (struct type *type, int field_num,
 
 static void
 print_variant_part (struct type *type, int field_num, struct type *outer_type,
-		    struct ui_file *stream, int show, int level)
+		    struct ui_file *stream, int show, int level,
+		    const struct type_print_options *flags)
 {
-  fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
-		    ada_variant_discrim_name
-		    (TYPE_FIELD_TYPE (type, field_num)));
+  const char *variant
+    = ada_variant_discrim_name (TYPE_FIELD_TYPE (type, field_num));
+  if (*variant == '\0')
+    variant = "?";
+
+  fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", variant);
   print_variant_clauses (type, field_num, outer_type, stream, show,
-			 level + 4);
+			 level + 4, flags);
   fprintf_filtered (stream, "\n%*send case;", level + 4, "");
 }
 
@@ -554,7 +615,8 @@ print_variant_part (struct type *type, int field_num, struct type *outer_type,
 static int
 print_selected_record_field_types (struct type *type, struct type *outer_type,
 				   int fld0, int fld1,
-				   struct ui_file *stream, int show, int level)
+				   struct ui_file *stream, int show, int level,
+				   const struct type_print_options *flags)
 {
   int i, flds;
 
@@ -571,10 +633,10 @@ print_selected_record_field_types (struct type *type, struct type *outer_type,
 	;
       else if (ada_is_wrapper_field (type, i))
 	flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
-					  stream, show, level);
+					  stream, show, level, flags);
       else if (ada_is_variant_part (type, i))
 	{
-	  print_variant_part (type, i, outer_type, stream, show, level);
+	  print_variant_part (type, i, outer_type, stream, show, level, flags);
 	  flds = 1;
 	}
       else
@@ -583,7 +645,7 @@ print_selected_record_field_types (struct type *type, struct type *outer_type,
 	  fprintf_filtered (stream, "\n%*s", level + 4, "");
 	  ada_print_type (TYPE_FIELD_TYPE (type, i),
 			  TYPE_FIELD_NAME (type, i),
-			  stream, show - 1, level + 4);
+			  stream, show - 1, level + 4, flags);
 	  fprintf_filtered (stream, ";");
 	}
     }
@@ -596,11 +658,12 @@ print_selected_record_field_types (struct type *type, struct type *outer_type,
 
 static int
 print_record_field_types (struct type *type, struct type *outer_type,
-			  struct ui_file *stream, int show, int level)
+			  struct ui_file *stream, int show, int level,
+			  const struct type_print_options *flags)
 {
   return print_selected_record_field_types (type, outer_type,
 					    0, TYPE_NFIELDS (type) - 1,
-					    stream, show, level);
+					    stream, show, level, flags);
 }
    
 
@@ -610,7 +673,7 @@ print_record_field_types (struct type *type, struct type *outer_type,
 
 static void
 print_record_type (struct type *type0, struct ui_file *stream, int show,
-		   int level)
+		   int level, const struct type_print_options *flags)
 {
   struct type *parent_type;
   struct type *type;
@@ -646,8 +709,9 @@ print_record_type (struct type *type0, struct ui_file *stream, int show,
       flds = 0;
       if (parent_type != NULL && ada_type_name (parent_type) == NULL)
 	flds += print_record_field_types (parent_type, parent_type,
-					  stream, show, level);
-      flds += print_record_field_types (type, type, stream, show, level);
+					  stream, show, level, flags);
+      flds += print_record_field_types (type, type, stream, show, level,
+					flags);
 
       if (flds > 0)
 	fprintf_filtered (stream, "\n%*send record", level, "");
@@ -664,7 +728,8 @@ print_record_type (struct type *type0, struct ui_file *stream, int show,
    number of levels of internal structure to show (see ada_print_type).  */
 static void
 print_unchecked_union_type (struct type *type, struct ui_file *stream,
-			    int show, int level)
+			    int show, int level,
+			    const struct type_print_options *flags)
 {
   if (show < 0)
     fprintf_filtered (stream, "record (?) is ... end record");
@@ -682,7 +747,7 @@ print_unchecked_union_type (struct type *type, struct ui_file *stream,
 			    level + 12, "");
 	  ada_print_type (TYPE_FIELD_TYPE (type, i),
 			  TYPE_FIELD_NAME (type, i),
-			  stream, show - 1, level + 12);
+			  stream, show - 1, level + 12, flags);
 	  fprintf_filtered (stream, ";");
 	}
 
@@ -697,17 +762,22 @@ print_unchecked_union_type (struct type *type, struct ui_file *stream,
    for function or procedure NAME if NAME is not null.  */
 
 static void
-print_func_type (struct type *type, struct ui_file *stream, const char *name)
+print_func_type (struct type *type, struct ui_file *stream, const char *name,
+		 const struct type_print_options *flags)
 {
   int i, len = TYPE_NFIELDS (type);
 
-  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
+  if (TYPE_TARGET_TYPE (type) != NULL
+      && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
     fprintf_filtered (stream, "procedure");
   else
     fprintf_filtered (stream, "function");
 
   if (name != NULL && name[0] != '\0')
-    fprintf_filtered (stream, " %s", name);
+    {
+      fputs_filtered (" ", stream);
+      fputs_styled (name, function_name_style.style (), stream);
+    }
 
   if (len > 0)
     {
@@ -720,15 +790,18 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name)
 	      wrap_here ("    ");
 	    }
 	  fprintf_filtered (stream, "a%d: ", i + 1);
-	  ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
+	  ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0,
+			  flags);
 	}
       fprintf_filtered (stream, ")");
     }
 
-  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
+  if (TYPE_TARGET_TYPE (type) == NULL)
+    fprintf_filtered (stream, " return <unknown return type>");
+  else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
     {
       fprintf_filtered (stream, " return ");
-      ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
+      ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
     }
 }
 
@@ -748,7 +821,8 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name)
 
 void
 ada_print_type (struct type *type0, const char *varstring,
-		struct ui_file *stream, int show, int level)
+		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);
@@ -759,7 +833,7 @@ ada_print_type (struct type *type0, const char *varstring,
       if (is_var_decl)
 	fprintf_filtered (stream, "%.*s: ",
 			  ada_name_prefix_len (varstring), varstring);
-      fprintf_filtered (stream, "<null type?>");
+      fprintf_styled (stream, metadata_style.style (), "<null type?>");
       return;
     }
 
@@ -778,29 +852,31 @@ ada_print_type (struct type *type0, const char *varstring,
     }
 
   if (ada_is_aligner_type (type))
-    ada_print_type (ada_aligned_type (type), "", stream, show, level);
+    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);
+    print_array_type (type, stream, show, level, flags);
   else
     switch (TYPE_CODE (type))
       {
       default:
 	fprintf_filtered (stream, "<");
-	c_print_type (type, "", stream, show, level);
+	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);
+	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);
+	ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+			flags);
 	break;
       case TYPE_CODE_ARRAY:
-	print_array_type (type, stream, show, level);
+	print_array_type (type, stream, show, level, flags);
 	break;
       case TYPE_CODE_BOOL:
 	fprintf_filtered (stream, "(false, true)");
@@ -813,12 +889,13 @@ ada_print_type (struct type *type0, const char *varstring,
 	    const char *name = ada_type_name (type);
 
 	    if (!ada_is_range_type_name (name))
-	      fprintf_filtered (stream, _("<%d-byte integer>"),
-				TYPE_LENGTH (type));
+	      fprintf_styled (stream, metadata_style.style (),
+			      _("<%s-byte integer>"),
+			      pulongest (TYPE_LENGTH (type)));
 	    else
 	      {
 		fprintf_filtered (stream, "range ");
-		print_range_type (type, stream);
+		print_range_type (type, stream, 1 /* bounds_prefered_p */);
 	      }
 	  }
 	break;
@@ -831,11 +908,13 @@ ada_print_type (struct type *type0, const char *varstring,
 	else
 	  {
 	    fprintf_filtered (stream, "range ");
-	    print_range (type, stream);
+	    print_range (type, stream, 1 /* bounds_prefered_p */);
 	  }
 	break;
       case TYPE_CODE_FLT:
-	fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
+	fprintf_styled (stream, metadata_style.style (),
+			_("<%s-byte float>"),
+			pulongest (TYPE_LENGTH (type)));
 	break;
       case TYPE_CODE_ENUM:
 	if (show < 0)
@@ -845,18 +924,18 @@ ada_print_type (struct type *type0, const char *varstring,
 	break;
       case TYPE_CODE_STRUCT:
 	if (ada_is_array_descriptor_type (type))
-	  print_array_type (type, stream, show, level);
+	  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);
+	  print_record_type (type, stream, show, level, flags);
 	break;
       case TYPE_CODE_UNION:
-	print_unchecked_union_type (type, stream, show, level);
+	print_unchecked_union_type (type, stream, show, level, flags);
 	break;
       case TYPE_CODE_FUNC:
-	print_func_type (type, stream, varstring);
+	print_func_type (type, stream, varstring, flags);
 	break;
       }
 }
@@ -868,6 +947,5 @@ 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);
-  fprintf_filtered (stream, "\n");
+  ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
 }