* ada-lang.c: run through gdb_indent.sh

        * ada-lang.h: run through gdb_indent.sh
        * ada-tasks.c: run through gdb_indent.sh
        * ada-typeprint.c: run through gdb_indent.sh
        * ada-valprint.c: run through gdb_indent.sh

1 files changed, 143 insertions, 142 deletions

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 3d651ed8310..fc2db703035 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -32,9 +32,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "c-lang.h"
 
 /* Encapsulates arguments to ada_val_print. */
-struct ada_val_print_args {
-  struct type* type;
-  char* valaddr0;
+struct ada_val_print_args
+{
+  struct type *type;
+  char *valaddr0;
   int embedded_offset;
   CORE_ADDR address;
   struct ui_file *stream;
@@ -47,45 +48,47 @@ struct ada_val_print_args {
 extern int inspect_it;
 extern unsigned int repeat_count_threshold;
 
-static void print_record (struct type*, char*, struct ui_file*, int,
+static void print_record (struct type *, char *, struct ui_file *, int,
 			  int, enum val_prettyprint);
 
-static int print_field_values (struct type*, char*, struct ui_file*, 
+static int print_field_values (struct type *, char *, struct ui_file *,
 			       int, int, enum val_prettyprint,
-			       int, struct type*, char*);
+			       int, struct type *, char *);
 
-static int print_variant_part (struct type*, int, char*, 
-			       struct ui_file*, int, int, enum val_prettyprint,
-			       int, struct type*, char*);
+static int print_variant_part (struct type *, int, char *,
+			       struct ui_file *, int, int,
+			       enum val_prettyprint, int, struct type *,
+			       char *);
 
-static void val_print_packed_array_elements (struct type*, char *valaddr, int,
-					     struct ui_file*, int, int, 
+static void val_print_packed_array_elements (struct type *, char *valaddr,
+					     int, struct ui_file *, int, int,
 					     enum val_prettyprint);
 
-static void adjust_type_signedness (struct type*);
+static void adjust_type_signedness (struct type *);
 
 static int ada_val_print_stub (PTR args0);
 
-static int ada_val_print_1 (struct type*, char*, int, CORE_ADDR, struct ui_file*,
-			    int, int, int, enum val_prettyprint);
+static int ada_val_print_1 (struct type *, char *, int, CORE_ADDR,
+			    struct ui_file *, int, int, int,
+			    enum val_prettyprint);
 
 
 /* Make TYPE unsigned if its range of values includes no negatives. */
-static void 
+static void
 adjust_type_signedness (type)
-     struct type* type;
+     struct type *type;
 {
-  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE 
+  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
       && TYPE_LOW_BOUND (type) >= 0)
     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
-}	
+}
 
 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
    if non-standard (i.e., other than 1 for numbers, other than lower bound
    of index type for enumerated type). Returns 1 if something printed, 
    otherwise 0. */
 
-static int 
+static int
 print_optional_low_bound (struct ui_file *stream, struct type *type)
 {
   struct type *index_type;
@@ -96,27 +99,28 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
 
   if (index_type == NULL)
     return 0;
-  if (TYPE_CODE (index_type) == TYPE_CODE_RANGE) 
+  if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
     {
       low_bound = TYPE_LOW_BOUND (index_type);
       index_type = TYPE_TARGET_TYPE (index_type);
     }
   else
     return 0;
-      
-  switch (TYPE_CODE (index_type)) {
-  case TYPE_CODE_ENUM:
-    if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
-      return 0;
-    break;
-  case TYPE_CODE_UNDEF:
-    index_type = builtin_type_long;
-    /* FALL THROUGH */
-  default:
-    if (low_bound == 1)
-      return 0;
-    break;
-  }
+
+  switch (TYPE_CODE (index_type))
+    {
+    case TYPE_CODE_ENUM:
+      if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
+	return 0;
+      break;
+    case TYPE_CODE_UNDEF:
+      index_type = builtin_type_long;
+      /* FALL THROUGH */
+    default:
+      if (low_bound == 1)
+	return 0;
+      break;
+    }
 
   ada_print_scalar (index_type, (LONGEST) low_bound, stream);
   fprintf_filtered (stream, " => ");
@@ -128,7 +132,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
     BITOFFSET from VALADDR on STREAM.  Formats according to FORMAT and
     separates with commas. RECURSE is the recursion (nesting) level.
     If PRETTY, uses "prettier" format. TYPE must have been decoded (as
-    by ada_coerce_to_simple_array).  */ 
+    by ada_coerce_to_simple_array).  */
 
 static void
 val_print_packed_array_elements (struct type *type, char *valaddr,
@@ -147,8 +151,8 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
   /* Number of repetitions we have detected so far.  */
   unsigned int reps;
   unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
-  struct value* mark = value_mark ();
-      
+  struct value *mark = value_mark ();
+
   elttype = TYPE_TARGET_TYPE (type);
   eltlen = TYPE_LENGTH (check_typedef (elttype));
 
@@ -183,7 +187,7 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
       wrap_here (n_spaces (2 + 2 * recurse));
 
       i0 = i;
-      v0 = ada_value_primitive_packed_val (NULL, valaddr, 
+      v0 = ada_value_primitive_packed_val (NULL, valaddr,
 					   (i0 * bitsize) / HOST_CHAR_BIT,
 					   (i0 * bitsize) % HOST_CHAR_BIT,
 					   bitsize, elttype);
@@ -192,12 +196,11 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
 	  i += 1;
 	  if (i >= len)
 	    break;
-	  v1 = ada_value_primitive_packed_val (NULL, valaddr, 
+	  v1 = ada_value_primitive_packed_val (NULL, valaddr,
 					       (i * bitsize) / HOST_CHAR_BIT,
 					       (i * bitsize) % HOST_CHAR_BIT,
 					       bitsize, elttype);
-	  if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) 
-	      != 0)
+	  if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) != 0)
 	    break;
 	}
 
@@ -215,7 +218,7 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
 	  int j;
 	  for (j = i0; j < i; j += 1)
 	    {
-	      if (j > i0) 
+	      if (j > i0)
 		{
 		  if (prettyprint_arrays)
 		    {
@@ -244,8 +247,8 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
   value_free_to_mark (mark);
 }
 
-static struct type*
-printable_val_type (struct type* type, char* valaddr)
+static struct type *
+printable_val_type (struct type *type, char *valaddr)
 {
   return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL);
 }
@@ -270,19 +273,19 @@ ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
 	fprintf_filtered (stream, "%c", c);
     }
   else
-    fprintf_filtered (stream, "[\"%0*x\"]", type_len*2, c);
+    fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
 }
 
 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
    or 2) of a character. */
 
 static int
-char_at (char* string, int i, int type_len)
+char_at (char *string, int i, int type_len)
 {
   if (type_len == 1)
     return string[i];
-  else 
-    return (int) extract_unsigned_integer (string + 2*i, 2);
+  else
+    return (int) extract_unsigned_integer (string + 2 * i, 2);
 }
 
 void
@@ -390,7 +393,7 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
   for (i = 0; i < length && things_printed < print_max; i += 1)
     {
       /* Position of the character we are examining
-	 to see whether it is repeated.  */
+         to see whether it is repeated.  */
       unsigned int rep1;
       /* Number of repetitions we have detected so far.  */
       unsigned int reps;
@@ -405,8 +408,9 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
 
       rep1 = i + 1;
       reps = 1;
-      while (rep1 < length && 
-	     char_at(string, rep1, type_len) == char_at (string, i, type_len))
+      while (rep1 < length &&
+	     char_at (string, rep1, type_len) == char_at (string, i,
+							  type_len))
 	{
 	  rep1 += 1;
 	  reps += 1;
@@ -423,7 +427,8 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
 	      in_quotes = 0;
 	    }
 	  fputs_filtered ("'", stream);
-	  ada_emit_char (char_at (string, i, type_len), stream, '\'', type_len);
+	  ada_emit_char (char_at (string, i, type_len), stream, '\'',
+			 type_len);
 	  fputs_filtered ("'", stream);
 	  fprintf_filtered (stream, " <repeats %u times>", reps);
 	  i = rep1 - 1;
@@ -487,12 +492,13 @@ ada_printstr (struct ui_file *stream, char *string, unsigned int length,
    arrays.)  */
 
 int
-ada_val_print (struct type* type, char* valaddr0, int embedded_offset,
+ada_val_print (struct type *type, char *valaddr0, int embedded_offset,
 	       CORE_ADDR address, struct ui_file *stream, int format,
 	       int deref_ref, int recurse, enum val_prettyprint pretty)
 {
   struct ada_val_print_args args;
-  args.type = type; args.valaddr0 = valaddr0; 
+  args.type = type;
+  args.valaddr0 = valaddr0;
   args.embedded_offset = embedded_offset;
   args.address = address;
   args.stream = stream;
@@ -509,18 +515,18 @@ ada_val_print (struct type* type, char* valaddr0, int embedded_offset,
 static int
 ada_val_print_stub (PTR args0)
 {
-  struct ada_val_print_args* argsp = (struct ada_val_print_args*) args0;
-  return ada_val_print_1 (argsp->type, argsp->valaddr0, argsp->embedded_offset,
-			  argsp->address, argsp->stream, argsp->format,
-			  argsp->deref_ref, argsp->recurse,
-			  argsp->pretty);
+  struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
+  return ada_val_print_1 (argsp->type, argsp->valaddr0,
+			  argsp->embedded_offset, argsp->address,
+			  argsp->stream, argsp->format, argsp->deref_ref,
+			  argsp->recurse, argsp->pretty);
 }
 
 /* See the comment on ada_val_print.  This function differs in that it
  * does not catch evaluation errors (leaving that to ada_val_print). */
 
 static int
-ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
+ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset,
 		 CORE_ADDR address, struct ui_file *stream, int format,
 		 int deref_ref, int recurse, enum val_prettyprint pretty)
 {
@@ -530,15 +536,15 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
   unsigned int eltlen;
   LONGEST val;
   CORE_ADDR addr;
-  char* valaddr = valaddr0 + embedded_offset;
+  char *valaddr = valaddr0 + embedded_offset;
 
   CHECK_TYPEDEF (type);
 
   if (ada_is_array_descriptor (type) || ada_is_packed_array_type (type))
     {
       int retn;
-      struct value* mark = value_mark ();
-      struct value* val;
+      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)
@@ -548,7 +554,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	}
       else
 	retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
-				VALUE_ADDRESS (val), stream, format, 
+				VALUE_ADDRESS (val), stream, format,
 				deref_ref, recurse, pretty);
       value_free_to_mark (mark);
       return retn;
@@ -561,7 +567,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
   switch (TYPE_CODE (type))
     {
     default:
-      return c_val_print (type, valaddr0, embedded_offset, address, stream, 
+      return c_val_print (type, valaddr0, embedded_offset, address, stream,
 			  format, deref_ref, recurse, pretty);
 
     case TYPE_CODE_INT:
@@ -577,26 +583,26 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	}
       else if (ada_is_vax_floating_type (type))
 	{
-	  struct value* val = 
+	  struct value *val =
 	    value_from_contents_and_address (type, valaddr, address);
-	  struct value* func = ada_vax_float_print_function (type);
+	  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 = 
+	      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)));
-	      
+				       call_function_by_hand (func, 1,
+							      &val)));
+
 	      fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val));
 	      return 0;
 	    }
@@ -604,26 +610,26 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	}
       else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
 	{
-	  struct type* target_type = TYPE_TARGET_TYPE (type);
+	  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));
+	         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), 
+	    return ada_val_print_1 (TYPE_TARGET_TYPE (type),
 				    valaddr0, embedded_offset,
-				    address,  stream, format, deref_ref, 
+				    address, stream, format, deref_ref,
 				    recurse, pretty);
 	}
-      else 
+      else
 	{
 	  format = format ? format : output_format;
 	  if (format)
@@ -661,8 +667,8 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	}
       if (i < len)
 	{
-	  const char* name = ada_enum_name (TYPE_FIELD_NAME (type, i));
-	  if (name[0] == '\'') 
+	  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);
@@ -672,18 +678,17 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	  print_longest (stream, 'd', 0, val);
 	}
       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);
+	  print_record (type, valaddr, stream, format, recurse, pretty);
 	  return 0;
 	}
 
@@ -693,21 +698,20 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	  elttype = TYPE_TARGET_TYPE (type);
 	  eltlen = TYPE_LENGTH (elttype);
 	  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 (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.  */
+	         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
@@ -715,7 +719,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 		       temp_len += 1);
 		  len = temp_len;
 		}
-	      
+
 	      printstr (stream, valaddr, len, 0, eltlen);
 	    }
 	  else
@@ -723,10 +727,9 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
 	      len = 0;
 	      fprintf_filtered (stream, "(");
 	      print_optional_low_bound (stream, type);
-	      if (TYPE_FIELD_BITSIZE (type, 0) > 0) 
+	      if (TYPE_FIELD_BITSIZE (type, 0) > 0)
 		val_print_packed_array_elements (type, valaddr, 0, stream,
-						 format, recurse,
-						 pretty);
+						 format, recurse, pretty);
 	      else
 		val_print_array_elements (type, valaddr, address, stream,
 					  format, deref_ref, recurse,
@@ -740,27 +743,27 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
     case TYPE_CODE_REF:
       elttype = check_typedef (TYPE_TARGET_TYPE (type));
       if (addressprint)
-        {
+	{
 	  fprintf_filtered (stream, "@");
 	  print_address_numeric
 	    (extract_address (valaddr,
 			      TARGET_PTR_BIT / HOST_CHAR_BIT), 1, stream);
 	  if (deref_ref)
 	    fputs_filtered (": ", stream);
-        }
+	}
       /* De-reference the reference */
       if (deref_ref)
 	{
 	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 	    {
-	      LONGEST deref_val_int = (LONGEST) 
-		unpack_pointer (lookup_pointer_type (builtin_type_void), 
+	      LONGEST deref_val_int = (LONGEST)
+		unpack_pointer (lookup_pointer_type (builtin_type_void),
 				valaddr);
-	      if (deref_val_int != 0) 
+	      if (deref_val_int != 0)
 		{
-		  struct value* deref_val =
-		    ada_value_ind (value_from_longest 
-				   (lookup_pointer_type (elttype), 
+		  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,
@@ -785,13 +788,12 @@ print_variant_part (struct type *type, int field_num, char *valaddr,
 		    struct type *outer_type, char *outer_valaddr)
 {
   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
-  int which = 
-    ada_which_variant_applies (var_type, outer_type, outer_valaddr);
+  int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
 
   if (which < 0)
     return 0;
   else
-    return print_field_values 
+    return print_field_values
       (TYPE_FIELD_TYPE (var_type, which),
        valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
        + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
@@ -800,23 +802,23 @@ print_variant_part (struct type *type, int field_num, char *valaddr,
 }
 
 int
-ada_value_print (struct value* val0, struct ui_file *stream, int format,
+ada_value_print (struct value *val0, struct ui_file *stream, int format,
 		 enum val_prettyprint pretty)
 {
-  char* valaddr = VALUE_CONTENTS (val0);
+  char *valaddr = VALUE_CONTENTS (val0);
   CORE_ADDR address = VALUE_ADDRESS (val0) + VALUE_OFFSET (val0);
-  struct type* type = 
+  struct type *type =
     ada_to_fixed_type (VALUE_TYPE (val0), valaddr, address, NULL);
-  struct value* val = value_from_contents_and_address (type, valaddr, address);
+  struct value *val =
+    value_from_contents_and_address (type, valaddr, address);
 
   /* If it is a pointer, indicate what it points to. */
-  if (TYPE_CODE (type) == TYPE_CODE_PTR ||
-      TYPE_CODE (type) == TYPE_CODE_REF)
+  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. */
+         type is indicated by the quoted string anyway. */
       if (TYPE_CODE (type) == TYPE_CODE_PTR &&
-	  TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof(char) &&
+	  TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof (char) &&
 	  TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT &&
 	  !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
 	{
@@ -829,7 +831,7 @@ ada_value_print (struct value* val0, struct ui_file *stream, int format,
 	  fprintf_filtered (stream, ") ");
 	}
     }
-  else if (ada_is_array_descriptor (type)) 
+  else if (ada_is_array_descriptor (type))
     {
       fprintf_filtered (stream, "(");
       type_print (type, "", stream, -1);
@@ -842,10 +844,10 @@ ada_value_print (struct value* val0, struct ui_file *stream, int format,
       fprintf_filtered (stream, ") (...?)");
       return 0;
     }
-  return (val_print (type, VALUE_CONTENTS (val), 0, address, 
+  return (val_print (type, VALUE_CONTENTS (val), 0, address,
 		     stream, format, 1, 0, pretty));
 }
- 
+
 static void
 print_record (struct type *type, char *valaddr, struct ui_file *stream,
 	      int format, int recurse, enum val_prettyprint pretty)
@@ -855,8 +857,7 @@ print_record (struct type *type, char *valaddr, struct ui_file *stream,
   fprintf_filtered (stream, "(");
 
   if (print_field_values (type, valaddr, stream, format, recurse, pretty,
-			  0, type, valaddr) != 0
-      && pretty)
+			  0, type, valaddr) != 0 && pretty)
     {
       fprintf_filtered (stream, "\n");
       print_spaces_filtered (2 * recurse, stream);
@@ -892,13 +893,13 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
   for (i = 0; i < len; i += 1)
     {
       if (ada_is_ignored_field (type, i))
-	  continue;
+	continue;
 
       if (ada_is_wrapper_field (type, i))
 	{
-	  comma_needed = 
+	  comma_needed =
 	    print_field_values (TYPE_FIELD_TYPE (type, i),
-				valaddr 
+				valaddr
 				+ TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
 				stream, format, recurse, pretty,
 				comma_needed, type, valaddr);
@@ -922,7 +923,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
 	  fprintf_filtered (stream, "\n");
 	  print_spaces_filtered (2 + 2 * recurse, stream);
 	}
-      else 
+      else
 	{
 	  wrap_here (n_spaces (2 + 2 * recurse));
 	}
@@ -942,7 +943,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
       else
 	{
 	  annotate_field_begin (TYPE_FIELD_TYPE (type, i));
-	  fprintf_filtered (stream, "%.*s", 
+	  fprintf_filtered (stream, "%.*s",
 			    ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
 			    TYPE_FIELD_NAME (type, i));
 	  annotate_field_name_end ();
@@ -952,7 +953,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
 
       if (TYPE_FIELD_PACKED (type, i))
 	{
-	  struct value* v;
+	  struct value *v;
 
 	  /* Bitfields require special handling, especially due to byte
 	     order problems.  */
@@ -965,21 +966,21 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
 	    {
 	      int bit_pos = TYPE_FIELD_BITPOS (type, i);
 	      int bit_size = TYPE_FIELD_BITSIZE (type, i);
-      
+
 	      adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
 	      v = ada_value_primitive_packed_val (NULL, valaddr,
 						  bit_pos / HOST_CHAR_BIT,
 						  bit_pos % HOST_CHAR_BIT,
-						  bit_size, 
+						  bit_size,
 						  TYPE_FIELD_TYPE (type, i));
-	      val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0, 0,
+	      val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
 			 stream, format, 0, recurse + 1, pretty);
 	    }
 	}
       else
-	  ada_val_print (TYPE_FIELD_TYPE (type, i), 
-		         valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
-		         0, 0, stream, format, 0, recurse + 1, pretty);
+	ada_val_print (TYPE_FIELD_TYPE (type, i),
+		       valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
+		       0, 0, stream, format, 0, recurse + 1, pretty);
       annotate_field_end ();
     }