This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[RFA] Evening up the right margins



Mark and Joel, I'm especially interested in your feedback.


This patch is meant to help even up the right margins without adding extra lines to the file. If folks approve, I'll do more.


2011-01-11  Michael Snyder  <msnyder@vmware.com>

	* ada-exp.y: Adjust right margin.
	* ada-lang.c: Ditto.
	* ada-lang.h: Ditto.
	* ada-lex.l: Ditto.
	* ada-tasks.c: Ditto.
	* ada-typeprint.c: Ditto.
	* ada-valprint.c: Ditto.

Index: ada-exp.y
===================================================================
RCS file: /cvs/src/src/gdb/ada-exp.y,v
retrieving revision 1.41
diff -u -p -u -p -r1.41 ada-exp.y
--- ada-exp.y	1 Jan 2011 15:32:55 -0000	1.41
+++ ada-exp.y	12 Jan 2011 03:12:28 -0000
@@ -64,7 +64,7 @@
    without BISON?  (PNH) */
 
 #define	yymaxdepth ada_maxdepth
-#define	yyparse	_ada_parse	/* ada_parse calls this after  initialization */
+#define	yyparse	_ada_parse     /* ada_parse calls this after  initialization */
 #define	yylex	ada_lex
 #define	yyerror	ada_error
 #define	yylval	ada_lval
@@ -192,8 +192,8 @@ static struct type *type_system_address 
 
 %token DOT_ALL
 
-/* Special type cases, put in to allow the parser to distinguish different
-   legal basetypes.  */
+/* Special type cases, put in to allow the parser to distinguish
+   different legal basetypes.  */
 %token <sval> SPECIAL_VARIABLE
 
 %nonassoc ASSIGN
@@ -205,9 +205,9 @@ static struct type *type_system_address 
 %left '*' '/' MOD REM
 %right STARSTAR ABS NOT
 
-/* Artificial token to give NAME => ... and NAME | priority over reducing 
-   NAME to <primary> and to give <primary>' priority over reducing <primary>
-   to <simple_exp>. */
+/* Artificial token to give NAME => ... and NAME | priority over
+   reducing NAME to <primary> and to give <primary>' priority over
+   reducing <primary> to <simple_exp>. */
 %nonassoc VAR
 
 %nonassoc ARROW '|'
@@ -215,9 +215,9 @@ static struct type *type_system_address 
 %right TICK_ACCESS TICK_ADDRESS TICK_FIRST TICK_LAST TICK_LENGTH
 %right TICK_MAX TICK_MIN TICK_MODULUS
 %right TICK_POS TICK_RANGE TICK_SIZE TICK_TAG TICK_VAL
- /* The following are right-associative only so that reductions at this
-    precedence have lower precedence than '.' and '('.  The syntax still
-    forces a.b.c, e.g., to be LEFT-associated.  */
+ /* The following are right-associative only so that reductions at
+    this precedence have lower precedence than '.' and '('.  The
+    syntax still forces a.b.c, e.g., to be LEFT-associated.  */
 %right '.' '(' '[' DOT_ID DOT_ALL
 
 %token NEW OTHERS
@@ -304,8 +304,8 @@ primary :	'(' exp1 ')'	{ }
    To get around it, we give '(' higher priority and add bridge rules for 
        var_or_type (exp, exp, ...)
        var_or_type (exp .. exp)
-   We also have the action for  var_or_type(exp) generate a function call
-   when the first symbol does not denote a type. */
+   We also have the action for  var_or_type(exp) generate a function
+   call when the first symbol does not denote a type. */
 
 primary :	var_or_type	%prec VAR
 			{ if ($1 != NULL)
@@ -381,7 +381,8 @@ simple_exp	:	simple_exp '/' simple_exp
 			{ write_exp_elt_opcode (BINOP_DIV); }
 	;
 
-simple_exp	:	simple_exp REM simple_exp /* May need to be fixed to give correct Ada REM */
+simple_exp	:	simple_exp REM simple_exp /* May need to be fixed to
+						     give correct Ada REM */
 			{ write_exp_elt_opcode (BINOP_REM); }
 	;
 
@@ -700,11 +701,11 @@ component_group :
 		        }
 	;
 
-/* We use this somewhat obscure definition in order to handle NAME => and
-   NAME | differently from exp => and exp |.  ARROW and '|' have a precedence
-   above that of the reduction of NAME to var_or_type.  By delaying 
-   decisions until after the => or '|', we convert the ambiguity to a 
-   resolved shift/reduce conflict. */
+/* We use this somewhat obscure definition in order to handle NAME =>
+   and NAME | differently from exp => and exp |.  ARROW and '|' have a
+   precedence above that of the reduction of NAME to var_or_type.  By
+   delaying decisions until after the => or '|', we convert the
+   ambiguity to a resolved shift/reduce conflict. */
 component_associations :
 		NAME ARROW 
 			{ write_name_assoc ($1); }
@@ -726,8 +727,8 @@ component_associations :
 		    component_associations  { $$ = $6 + 1; }
 	;
 
-/* Some extensions borrowed from C, for the benefit of those who find they
-   can't get used to Ada notation in GDB.  */
+/* Some extensions borrowed from C, for the benefit of those who find
+   they can't get used to Ada notation in GDB.  */
 
 primary	:	'*' primary		%prec '.'
 			{ write_exp_elt_opcode (UNOP_IND); }
@@ -759,8 +760,8 @@ primary	:	'*' primary		%prec '.'
 
 static struct obstack temp_parse_space;
 
-/* The following kludge was found necessary to prevent conflicts between */
-/* defs.h and non-standard stdlib.h files.  */
+/* The following kludge was found necessary to prevent conflicts */
+/* between defs.h and non-standard stdlib.h files.  */
 #define qsort __qsort__dummy
 #include "ada-lex.c"
 
@@ -877,8 +878,8 @@ write_object_renaming (struct block *ori
     orig_left_context = get_selected_block (NULL);
 
   name = obsavestring (renamed_entity, renamed_entity_len, &temp_parse_space);
-  sym = ada_lookup_encoded_symbol (name, orig_left_context, VAR_DOMAIN, 
-				   &block);
+  sym = ada_lookup_encoded_symbol (name, orig_left_context,
+				   VAR_DOMAIN, &block);
   if (sym == NULL)
     error (_("Could not find renamed variable: %s"), ada_decode (name));
   else if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
@@ -899,8 +900,8 @@ write_object_renaming (struct block *ori
 	write_var_from_sym (orig_left_context, block, sym);
 	break;
       case ADA_OBJECT_RENAMING:
-	write_object_renaming (block,
-			       inner_renamed_entity, inner_renamed_entity_len,
+	write_object_renaming (block, inner_renamed_entity,
+			       inner_renamed_entity_len,
 			       inner_renaming_expr, max_depth - 1);
 	break;
       default:
@@ -1151,9 +1152,10 @@ write_selectors (char *sels)
 }
 
 /* Write a variable access (OP_VAR_VALUE) to ambiguous encoded name
-   NAME[0..LEN-1], in block context BLOCK, to be resolved later.  Writes
-   a temporary symbol that is valid until the next call to ada_parse.
-   */
+   NAME[0..LEN-1], in block context BLOCK, to be resolved later.
+   Writes a temporary symbol that is valid until the next call to
+   ada_parse.  */
+
 static void
 write_ambiguous_var (struct block *block, char *name, int len)
 {
Index: ada-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-lang.c,v
retrieving revision 1.283
diff -u -p -u -p -r1.283 ada-lang.c
--- ada-lang.c	11 Jan 2011 19:23:02 -0000	1.283
+++ ada-lang.c	12 Jan 2011 03:12:28 -0000
@@ -105,9 +105,9 @@ static int full_match (const char *, con
 
 static struct value *make_array_descriptor (struct type *, struct value *);
 
-static void ada_add_block_symbols (struct obstack *,
-                                   struct block *, const char *,
-                                   domain_enum, struct objfile *, int);
+static void ada_add_block_symbols (struct obstack *, struct block *,
+                                   const char *, domain_enum, 
+                                  struct objfile *, int);
 
 static int is_nonfunction (struct ada_symbol_info *, int);
 
@@ -212,11 +212,11 @@ static struct value *value_val_atr (stru
 static struct symbol *standard_lookup (const char *, const struct block *,
                                        domain_enum);
 
-static struct value *ada_search_struct_field (char *, struct value *, int,
-                                              struct type *);
+static struct value *ada_search_struct_field (char *, struct value *,
+                                              int, struct type *);
 
-static struct value *ada_value_primitive_field (struct value *, int, int,
-                                                struct type *);
+static struct value *ada_value_primitive_field (struct value *, int,
+                                                int, struct type *);
 
 static int find_struct_field (char *, struct type *, int,
                               struct type **, int *, int *, int *, int *);
@@ -249,13 +249,13 @@ static void aggregate_assign_from_choice
 
 static void aggregate_assign_positional (struct value *, struct value *,
 					 struct expression *,
-					 int *, LONGEST *, int *, int,
-					 LONGEST, LONGEST);
+					 int *, LONGEST *, int *,
+					 int, LONGEST, LONGEST);
 
 
 static void aggregate_assign_others (struct value *, struct value *,
-				     struct expression *,
-				     int *, LONGEST *, int, LONGEST, LONGEST);
+				     struct expression *, int *,
+				     LONGEST *, int, LONGEST, LONGEST);
 
 
 static void add_component_interval (LONGEST, LONGEST, LONGEST *, int *, int);
@@ -264,8 +264,8 @@ static void add_component_interval (LONG
 static struct value *ada_evaluate_subexp (struct type *, struct expression *,
 					  int *, enum noside);
 
-static void ada_forward_operator_length (struct expression *, int, int *,
-					 int *);
+static void ada_forward_operator_length (struct expression *, int,
+					 int *, int *);
 
 
 
@@ -484,9 +484,9 @@ field_name_match (const char *field_name
    a TYPE_CODE_STRUCT, find the field whose name matches FIELD_NAME,
    and return its index.  This function also handles fields whose name
    have ___ suffixes because the compiler sometimes alters their name
-   by adding such a suffix to represent fields with certain constraints.
-   If the field could not be found, return a negative number if
-   MAYBE_MISSING is set.  Otherwise raise an error.  */
+   by adding such a suffix to represent fields with certain
+   constraints.  If the field could not be found, return a negative
+   number if MAYBE_MISSING is set.  Otherwise raise an error.  */
 
 int
 ada_get_field_index (const struct type *type, const char *field_name,
@@ -725,8 +725,8 @@ base_type (struct type *type)
 
                                 /* Language Selection */
 
-/* If the main program is in Ada, return language_ada, otherwise return LANG
-   (the main program is in Ada iif the adainit symbol is found).  */
+/* If the main program is in Ada, return language_ada, otherwise return
+   LANG (the main program is in Ada iif the adainit symbol is found).  */
 
 enum language
 ada_update_initial_language (enum language lang)
@@ -779,8 +779,8 @@ ada_main_name (void)
 
                                 /* Symbols */
 
-/* Table of Ada operators and their GNAT-encoded names.  Last entry is pair
-   of NULLs.  */
+/* Table of Ada operators and their GNAT-encoded names.  Last entry is
+   pair of NULLs.  */
 
 const struct ada_opname_map ada_opname_table[] = {
   {"Oadd", "\"+\"", BINOP_ADD},
@@ -966,13 +966,13 @@ ada_remove_Xbn_suffix (const char *encod
     *len = i;
 }
 
-/* If ENCODED follows the GNAT entity encoding conventions, then return
-   the decoded form of ENCODED.  Otherwise, return "<%s>" where "%s" is
-   replaced by ENCODED.
+/* If ENCODED follows the GNAT entity encoding conventions, then
+   return the decoded form of ENCODED.  Otherwise, return "<%s>"
+   where "%s" is replaced by ENCODED.
 
    The resulting string is valid until the next call of ada_decode.
-   If the string is unchanged by decoding, the original string pointer
-   is returned.  */
+   If the string is unchanged by decoding, the original string
+   pointer is returned.  */
 
 const char *
 ada_decode (const char *encoded)
@@ -1002,10 +1002,10 @@ ada_decode (const char *encoded)
   ada_remove_trailing_digits (encoded, &len0);
   ada_remove_po_subprogram_suffix (encoded, &len0);
 
-  /* Remove the ___X.* suffix if present.  Do not forget to verify that
-     the suffix is located before the current "end" of ENCODED.  We want
-     to avoid re-matching parts of ENCODED that have previously been
-     marked as discarded (by decrementing LEN0).  */
+  /* Remove the ___X.* suffix if present.  Do not forget to verify
+     that the suffix is located before the current "end" of ENCODED.
+     We want to avoid re-matching parts of ENCODED that have
+     previously been marked as discarded (by decrementing LEN0).  */
   p = strstr (encoded, "___");
   if (p != NULL && p - encoded < len0 - 3)
     {
@@ -1015,16 +1015,16 @@ ada_decode (const char *encoded)
         goto Suppress;
     }
 
-  /* Remove any trailing TKB suffix.  It tells us that this symbol
-     is for the body of a task, but that information does not actually
+  /* Remove any trailing TKB suffix.  It tells us that this symbol is
+     for the body of a task, but that information does not actually
      appear in the decoded name.  */
 
   if (len0 > 3 && strncmp (encoded + len0 - 3, "TKB", 3) == 0)
     len0 -= 3;
 
-  /* Remove any trailing TB suffix.  The TB suffix is slightly different
-     from the TKB suffix because it is used for non-anonymous task
-     bodies.  */
+  /* Remove any trailing TB suffix.  The TB suffix is slightly
+     different from the TKB suffix because it is used for
+     non-anonymous task bodies.  */
 
   if (len0 > 2 && strncmp (encoded + len0 - 2, "TB", 2) == 0)
     len0 -= 2;
@@ -1071,8 +1071,8 @@ ada_decode (const char *encoded)
           for (k = 0; ada_opname_table[k].encoded != NULL; k += 1)
             {
               int op_len = strlen (ada_opname_table[k].encoded);
-              if ((strncmp (ada_opname_table[k].encoded + 1, encoded + i + 1,
-                            op_len - 1) == 0)
+              if ((strncmp (ada_opname_table[k].encoded + 1,
+                            encoded + i + 1, op_len - 1) == 0)
                   && !isalnum (encoded[i + op_len]))
                 {
                   strcpy (decoded + j, ada_opname_table[k].decoded);
@@ -1114,16 +1114,16 @@ ada_decode (const char *encoded)
 
       /* Remove _E{DIGITS}+[sb] */
 
-      /* Just as for protected object subprograms, there are 2 categories
-         of subprograms created by the compiler for each entry.  The first
-         one implements the actual entry code, and has a suffix following
-         the convention above; the second one implements the barrier and
-         uses the same convention as above, except that the 'E' is replaced
-         by a 'B'.
+      /* Just as for protected object subprograms, there are 2
+         categories of subprograms created by the compiler for each
+         entry.  The first one implements the actual entry code, and
+         has a suffix following the convention above; the second one
+         implements the barrier and uses the same convention as above,
+         except that the 'E' is replaced by a 'B'.
 
          Just as above, we do not decode the name of barrier functions
-         to give the user a clue that the code he is debugging has been
-         internally generated.  */
+         to give the user a clue that the code he is debugging has
+         been internally generated.  */
 
       if (len0 - i > 3 && encoded [i] == '_' && encoded[i+1] == 'E'
           && isdigit (encoded[i+2]))
@@ -1149,8 +1149,8 @@ ada_decode (const char *encoded)
       /* Remove trailing "N" in [a-z0-9]+N__.  The N is added by
          the GNAT front-end in protected object subprograms.  */
 
-      if (i < len0 + 3
-          && encoded[i] == 'N' && encoded[i+1] == '_' && encoded[i+2] == '_')
+      if (i < len0 + 3 && encoded[i] == 'N'
+	  && encoded[i+1] == '_' && encoded[i+2] == '_')
         {
           /* Backtrack a bit up until we reach either the begining of
              the encoded name, or "__".  Make sure that we only find
@@ -1167,12 +1167,12 @@ ada_decode (const char *encoded)
       if (encoded[i] == 'X' && i != 0 && isalnum (encoded[i - 1]))
         {
           /* This is a X[bn]* sequence not separated from the previous
-             part of the name with a non-alpha-numeric character (in other
-             words, immediately following an alpha-numeric character), then
-             verify that it is placed at the end of the encoded name.  If
-             not, then the encoding is not valid and we should abort the
-             decoding.  Otherwise, just skip it, it is used in body-nested
-             package names.  */
+             part of the name with a non-alpha-numeric character (in
+             other words, immediately following an alpha-numeric
+             character), then verify that it is placed at the end of
+             the encoded name.  If not, then the encoding is not valid
+             and we should abort the decoding.  Otherwise, just skip
+             it, it is used in body-nested package names.  */
           do
             i += 1;
           while (i < len0 && (encoded[i] == 'b' || encoded[i] == 'n'));
@@ -1189,8 +1189,8 @@ ada_decode (const char *encoded)
         }
       else
         {
-          /* It's a character part of the decoded name, so just copy it
-             over.  */
+          /* It's a character part of the decoded name, so just copy
+             it over.  */
           decoded[j] = encoded[i];
           i += 1;
           j += 1;
@@ -1309,27 +1309,28 @@ match_name (const char *sym_name, const 
                                 /* Arrays */
 
 /* Assuming that INDEX_DESC_TYPE is an ___XA structure, a structure
-   generated by the GNAT compiler to describe the index type used
-   for each dimension of an array, check whether it follows the latest
-   known encoding.  If not, fix it up to conform to the latest encoding.
-   Otherwise, do nothing.  This function also does nothing if
-   INDEX_DESC_TYPE is NULL.
-
-   The GNAT encoding used to describle the array index type evolved a bit.
-   Initially, the information would be provided through the name of each
-   field of the structure type only, while the type of these fields was
-   described as unspecified and irrelevant.  The debugger was then expected
-   to perform a global type lookup using the name of that field in order
-   to get access to the full index type description.  Because these global
-   lookups can be very expensive, the encoding was later enhanced to make
-   the global lookup unnecessary by defining the field type as being
-   the full index type description.
-
-   The purpose of this routine is to allow us to support older versions
-   of the compiler by detecting the use of the older encoding, and by
-   fixing up the INDEX_DESC_TYPE to follow the new one (at this point,
-   we essentially replace each field's meaningless type by the associated
-   index subtype).  */
+   generated by the GNAT compiler to describe the index type used for
+   each dimension of an array, check whether it follows the latest
+   known encoding.  If not, fix it up to conform to the latest
+   encoding.  Otherwise, do nothing.  This function also does nothing
+   if INDEX_DESC_TYPE is NULL.
+
+   The GNAT encoding used to describle the array index type evolved a
+   bit.  Initially, the information would be provided through the name
+   of each field of the structure type only, while the type of these
+   fields was described as unspecified and irrelevant.  The debugger
+   was then expected to perform a global type lookup using the name of
+   that field in order to get access to the full index type
+   description.  Because these global lookups can be very expensive,
+   the encoding was later enhanced to make the global lookup
+   unnecessary by defining the field type as being the full index type
+   description.
+
+   The purpose of this routine is to allow us to support older
+   versions of the compiler by detecting the use of the older
+   encoding, and by fixing up the INDEX_DESC_TYPE to follow the new
+   one (at this point, we essentially replace each field's meaningless
+   type by the associated index subtype).  */
 
 void
 ada_fixup_array_indexes_type (struct type *index_desc_type)
@@ -1340,9 +1341,9 @@ ada_fixup_array_indexes_type (struct typ
     return;
   gdb_assert (TYPE_NFIELDS (index_desc_type) > 0);
 
-  /* Check if INDEX_DESC_TYPE follows the older encoding (it is sufficient
-     to check one field only, no need to check them all).  If not, return
-     now.
+  /* Check if INDEX_DESC_TYPE follows the older encoding (it is
+     sufficient to check one field only, no need to check them all).
+     If not, return now.
 
      If our INDEX_DESC_TYPE was generated using the older encoding,
      the field type should be a meaningless integer type whose name
@@ -1564,10 +1565,10 @@ fat_pntr_bounds_bitsize (struct type *ty
     return 8 * TYPE_LENGTH (ada_check_typedef (TYPE_FIELD_TYPE (type, 1)));
 }
 
-/* If TYPE is the type of an array descriptor (fat or thin pointer) or a
-   pointer to one, the type of its array data (a array-with-no-bounds type);
-   otherwise, NULL.  Use ada_type_of_array to get an array type with bounds
-   data.  */
+/* If TYPE is the type of an array descriptor (fat or thin pointer) or
+   a pointer to one, the type of its array data (a
+   array-with-no-bounds type); otherwise, NULL.  Use ada_type_of_array
+   to get an array type with bounds data.  */
 
 static struct type *
 desc_data_target_type (struct type *type)
@@ -1637,13 +1638,13 @@ fat_pntr_data_bitsize (struct type *type
 static struct value *
 desc_one_bound (struct value *bounds, int i, int which)
 {
-  return value_struct_elt (&bounds, NULL, bound_name[2 * i + which - 2], NULL,
-                           _("Bad GNAT array descriptor bounds"));
+  return value_struct_elt (&bounds, NULL, bound_name[2 * i + which - 2],
+                           NULL, _("Bad GNAT array descriptor bounds"));
 }
 
-/* If BOUNDS is an array-bounds structure type, return the bit position
-   of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
-   bound, if WHICH is 1.  The first bound is I=1.  */
+/* If BOUNDS is an array-bounds structure type, return the bit
+   position of the Ith lower bound stored in it, if WHICH is 0, and
+   the Ith upper bound, if WHICH is 1.  The first bound is I=1.  */
 
 static int
 desc_bound_bitpos (struct type *type, int i, int which)
@@ -1651,9 +1652,9 @@ desc_bound_bitpos (struct type *type, in
   return TYPE_FIELD_BITPOS (desc_base_type (type), 2 * i + which - 2);
 }
 
-/* If BOUNDS is an array-bounds structure type, return the bit field size
-   of the Ith lower bound stored in it, if WHICH is 0, and the Ith upper
-   bound, if WHICH is 1.  The first bound is I=1.  */
+/* If BOUNDS is an array-bounds structure type, return the bit field
+   size of the Ith lower bound stored in it, if WHICH is 0, and the
+   Ith upper bound, if WHICH is 1.  The first bound is I=1.  */
 
 static int
 desc_bound_bitsize (struct type *type, int i, int which)
@@ -1765,13 +1766,13 @@ ada_is_bogus_array_descriptor (struct ty
 }
 
 
-/* If ARR has a record type in the form of a standard GNAT array descriptor,
-   (fat pointer) returns the type of the array data described---specifically,
-   a pointer-to-array type.  If BOUNDS is non-zero, the bounds data are filled
-   in from the descriptor; otherwise, they are left unspecified.  If
-   the ARR denotes a null array descriptor and BOUNDS is non-zero,
-   returns NULL.  The result is simply the type of ARR if ARR is not
-   a descriptor.  */
+/* If ARR has a record type in the form of a standard GNAT array
+   descriptor, (fat pointer) returns the type of the array data
+   described---specifically, a pointer-to-array type.  If BOUNDS is
+   non-zero, the bounds data are filled in from the descriptor;
+   otherwise, they are left unspecified.  If the ARR denotes a null
+   array descriptor and BOUNDS is non-zero, returns NULL.  The result
+   is simply the type of ARR if ARR is not a descriptor.  */
 struct type *
 ada_type_of_array (struct value *arr, int bounds)
 {
@@ -1831,8 +1832,8 @@ ada_type_of_array (struct value *arr, in
 
 /* If ARR does not represent an array, returns ARR unchanged.
    Otherwise, returns either a standard GDB array with bounds set
-   appropriately or, if ARR is a non-null fat pointer, a pointer to a standard
-   GDB array.  Returns NULL if ARR is a null fat pointer.  */
+   appropriately or, if ARR is a non-null fat pointer, a pointer to a
+   standard GDB array.  Returns NULL if ARR is a null fat pointer.  */
 
 struct value *
 ada_coerce_to_simple_array_ptr (struct value *arr)
@@ -1923,8 +1924,8 @@ ada_is_unconstrained_packed_array_type (
     && ada_is_array_descriptor_type (type);
 }
 
-/* Given that TYPE encodes a packed array type (constrained or unconstrained),
-   return the size of its elements in bits.  */
+/* Given that TYPE encodes a packed array type (constrained or
+   unconstrained), return the size of its elements in bits.  */
 
 static long
 decode_packed_array_bitsize (struct type *type)
@@ -1933,9 +1934,9 @@ decode_packed_array_bitsize (struct type
   char *tail;
   long bits;
 
-  /* Access to arrays implemented as fat pointers are encoded as a typedef
-     of the fat pointer type.  We need the name of the fat pointer type
-     to do the decoding, so strip the typedef layer.  */
+  /* Access to arrays implemented as fat pointers are encoded as a
+     typedef of the fat pointer type.  We need the name of the fat
+     pointer type to do the decoding, so strip the typedef layer.  */
   if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
     type = ada_typedef_target_type (type);
 
@@ -2048,11 +2049,11 @@ decode_constrained_packed_array_type (st
   return constrained_packed_array_type (shadow_type, &bits);
 }
 
-/* Given that ARR is a struct value *indicating a GNAT constrained packed
-   array, returns a simple array that denotes that array.  Its type is a
-   standard GDB array type except that the BITSIZEs of the array
-   target types are set to the number of bits in each element, and the
-   type length is set appropriately.  */
+/* Given that ARR is a struct value *indicating a GNAT constrained
+   packed array, returns a simple array that denotes that array.  Its
+   type is a standard GDB array type except that the BITSIZEs of the
+   array target types are set to the number of bits in each element,
+   and the type length is set appropriately.  */
 
 static struct value *
 decode_constrained_packed_array (struct value *arr)
@@ -2064,9 +2065,9 @@ decode_constrained_packed_array (struct 
   /* If our value is a pointer, then dererence it.  Make sure that
      this operation does not cause the target type to be fixed, as
      this would indirectly cause this array to be decoded.  The rest
-     of the routine assumes that the array hasn't been decoded yet,
-     so we use the basic "value_ind" routine to perform the dereferencing,
-     as opposed to using "ada_value_ind".  */
+     of the routine assumes that the array hasn't been decoded yet, so
+     we use the basic "value_ind" routine to perform the
+     dereferencing, as opposed to using "ada_value_ind".  */
   if (TYPE_CODE (value_type (arr)) == TYPE_CODE_PTR)
     arr = value_ind (arr);
 
@@ -2080,10 +2081,10 @@ decode_constrained_packed_array (struct 
   if (gdbarch_bits_big_endian (get_type_arch (value_type (arr)))
       && ada_is_modular_type (value_type (arr)))
     {
-       /* This is a (right-justified) modular type representing a packed
- 	 array with no wrapper.  In order to interpret the value through
- 	 the (left-justified) packed array type we just built, we must
- 	 first left-justify it.  */
+       /* This is a (right-justified) modular type representing a
+ 	 packed array with no wrapper.  In order to interpret the
+ 	 value through the (left-justified) packed array type we just
+ 	 built, we must first left-justify it.  */
       int bit_size, bit_pos;
       ULONGEST mod;
 
@@ -2201,8 +2202,8 @@ ada_value_primitive_packed_val (struct v
   unsigned long accum;          /* Staging area for bits being transferred */
   unsigned char sign;
   int len = (bit_size + bit_offset + HOST_CHAR_BIT - 1) / 8;
-  /* Transmit bytes from least to most significant; delta is the direction
-     the indices move.  */
+  /* Transmit bytes from least to most significant; delta is the
+     direction the indices move.  */
   int delta = gdbarch_bits_big_endian (get_type_arch (type)) ? -1 : 1;
 
   type = ada_check_typedef (type);
@@ -2272,8 +2273,8 @@ ada_value_primitive_packed_val (struct v
           /* Non-scalar values must be aligned at a byte boundary...  */
           accumSize =
             (HOST_CHAR_BIT - bit_size % HOST_CHAR_BIT) % HOST_CHAR_BIT;
-          /* ... And are placed at the beginning (most-significant) bytes
-             of the target.  */
+          /* ... And are placed at the beginning (most-significant)
+             bytes of the target.  */
           targ = (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT - 1;
           ntarg = targ + 1;
           break;
@@ -2301,13 +2302,13 @@ ada_value_primitive_packed_val (struct v
       /* Mask for removing bits of the next source byte that are not
          part of the value.  */
       unsigned int unusedMSMask =
-        (1 << (srcBitsLeft >= HOST_CHAR_BIT ? HOST_CHAR_BIT : srcBitsLeft)) -
-        1;
+        (1 << (srcBitsLeft >= HOST_CHAR_BIT
+	       ? HOST_CHAR_BIT : srcBitsLeft)) - 1;
       /* Sign-extend bits for this byte.  */
       unsigned int signMask = sign & ~unusedMSMask;
 
-      accum |=
-        (((bytes[src] >> unusedLS) & unusedMSMask) | signMask) << accumSize;
+      accum |= (((bytes[src] >> unusedLS) 
+		 & unusedMSMask) | signMask) << accumSize;
       accumSize += HOST_CHAR_BIT - unusedLS;
       if (accumSize >= HOST_CHAR_BIT)
         {
@@ -2367,9 +2368,8 @@ move_bits (gdb_byte *target, int targ_of
             chunk_size = n;
           unused_right = HOST_CHAR_BIT - (chunk_size + targ_offset);
           mask = ((1 << chunk_size) - 1) << unused_right;
-          *target =
-            (*target & ~mask)
-            | ((accum >> (accum_bits - chunk_size - unused_right)) & mask);
+          *target = (*target & ~mask)
+	    | ((accum >> (accum_bits - chunk_size - unused_right)) & mask);
           n -= chunk_size;
           accum_bits -= chunk_size;
           target += 1;
@@ -2469,8 +2469,8 @@ ada_value_assign (struct value *toval, s
  * COMPONENT, and not the inferior's memory.  The current contents 
  * of COMPONENT are ignored.  */
 static void
-value_assign_to_component (struct value *container, struct value *component,
-			   struct value *val)
+value_assign_to_component (struct value *container,
+			   struct value *component, struct value *val)
 {
   LONGEST offset_in_container =
     (LONGEST)  (value_address (component) - value_address (container));
@@ -2497,9 +2497,9 @@ value_assign_to_component (struct value 
 	       value_contents (val), 0, bits, 0);
 }	       
 			
-/* The value of the element of array ARR at the ARITY indices given in IND.
-   ARR may be either a simple array, GNAT array descriptor, or pointer
-   thereto.  */
+/* The value of the element of array ARR at the ARITY indices given in
+   IND.  ARR may be either a simple array, GNAT array descriptor, or
+   pointer thereto.  */
 
 struct value *
 ada_value_subscript (struct value *arr, int arity, struct value **ind)
@@ -2525,12 +2525,12 @@ ada_value_subscript (struct value *arr, 
 }
 
 /* Assuming ARR is a pointer to a standard GDB array of type TYPE, the
-   value of the element of *ARR at the ARITY indices given in
-   IND.  Does not read the entire array into memory.  */
+   value of the element of *ARR at the ARITY indices given in IND.
+   Does not read the entire array into memory.  */
 
 static struct value *
-ada_value_ptr_subscript (struct value *arr, struct type *type, int arity,
-                         struct value **ind)
+ada_value_ptr_subscript (struct value *arr, struct type *type,
+                         int arity, struct value **ind)
 {
   int k;
 
@@ -2550,10 +2550,11 @@ ada_value_ptr_subscript (struct value *a
   return value_ind (arr);
 }
 
-/* Given that ARRAY_PTR is a pointer or reference to an array of type TYPE (the
-   actual type of ARRAY_PTR is ignored), returns the Ada slice of HIGH-LOW+1
-   elements starting at index LOW.  The lower bound of this array is LOW, as
-   per Ada rules.  */
+/* Given that ARRAY_PTR is a pointer or reference to an array of type
+   TYPE (the actual type of ARRAY_PTR is ignored), returns the Ada
+   slice of HIGH-LOW+1 elements starting at index LOW.  The lower
+   bound of this array is LOW, as per Ada rules.  */
+
 static struct value *
 ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
                           int low, int high)
@@ -2658,8 +2659,8 @@ ada_array_element_type (struct type *typ
 /* The type of nth index in arrays of given type (n numbering from 1).
    Does not examine memory.  Throws an error if N is invalid or TYPE
    is not an array type.  NAME is the name of the Ada attribute being
-   evaluated ('range, 'first, 'last, or 'length); it is used in building
-   the error message.  */
+   evaluated ('range, 'first, 'last, or 'length); it is used in
+   building the error message.  */
 
 static struct type *
 ada_index_type (struct type *type, int n, const char *name)
@@ -2678,8 +2679,8 @@ ada_index_type (struct type *type, int n
       for (i = 1; i < n; i += 1)
         type = TYPE_TARGET_TYPE (type);
       result_type = TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type));
-      /* FIXME: The stabs type r(0,0);bound;bound in an array type
-         has a target type of TYPE_CODE_UNDEF.  We compensate here, but
+      /* FIXME: The stabs type r(0,0);bound;bound in an array type has
+         a target type of TYPE_CODE_UNDEF.  We compensate here, but
          perhaps stabsread.c would make more sense.  */
       if (result_type && TYPE_CODE (result_type) == TYPE_CODE_UNDEF)
         result_type = NULL;
@@ -2694,11 +2695,11 @@ ada_index_type (struct type *type, int n
   return result_type;
 }
 
-/* Given that arr is an array type, returns the lower bound of the
-   Nth index (numbering from 1) if WHICH is 0, and the upper bound if
+/* Given that arr is an array type, returns the lower bound of the Nth
+   index (numbering from 1) if WHICH is 0, and the upper bound if
    WHICH is 1.  This returns bounds 0 .. -1 if ARR_TYPE is an
-   array-descriptor type.  It works for other arrays with bounds supplied
-   by run-time quantities other than discriminants.  */
+   array-descriptor type.  It works for other arrays with bounds
+   supplied by run-time quantities other than discriminants.  */
 
 static LONGEST
 ada_array_bound_from_type (struct type * arr_type, int n, int which)
@@ -2726,8 +2727,8 @@ ada_array_bound_from_type (struct type *
   index_type_desc = ada_find_parallel_type (type, "___XA");
   ada_fixup_array_indexes_type (index_type_desc);
   if (index_type_desc != NULL)
-    index_type = to_fixed_range_type (TYPE_FIELD_TYPE (index_type_desc, n - 1),
-				      NULL);
+    index_type = to_fixed_range_type (TYPE_FIELD_TYPE (index_type_desc,
+						       n - 1), NULL);
   else
     index_type = TYPE_INDEX_TYPE (elt_type);
 
@@ -2755,11 +2756,11 @@ ada_array_bound (struct value *arr, int 
     return value_as_long (desc_one_bound (desc_bounds (arr), n, which));
 }
 
-/* Given that arr is an array value, returns the length of the
-   nth index.  This routine will also work for arrays with bounds
-   supplied by run-time quantities other than discriminants.
-   Does not work for arrays indexed by enumeration types with representation
-   clauses at the moment.  */
+/* Given that arr is an array value, returns the length of the nth
+   index.  This routine will also work for arrays with bounds supplied
+   by run-time quantities other than discriminants.  Does not work for
+   arrays indexed by enumeration types with representation clauses at
+   the moment.  */
 
 static LONGEST
 ada_array_length (struct value *arr, int n)
@@ -2794,8 +2795,8 @@ empty_array (struct type *arr_type, int 
 
                                 /* Name resolution */
 
-/* The "decoded" name for the user-definable Ada operator corresponding
-   to OP.  */
+/* The "decoded" name for the user-definable Ada operator
+   corresponding to OP.  */
 
 static const char *
 ada_decoded_op_name (enum exp_opcode op)
@@ -2832,13 +2833,13 @@ resolve (struct expression **expp, int v
   resolve_subexp (expp, &pc, 1, context_type);
 }
 
-/* Resolve the operator of the subexpression beginning at
-   position *POS of *EXPP.  "Resolving" consists of replacing
-   the symbols that have undefined namespaces in OP_VAR_VALUE nodes
-   with their resolutions, replacing built-in operators with
-   function calls to user-defined operators, where appropriate, and,
-   when DEPROCEDURE_P is non-zero, converting function-valued variables
-   into parameterless calls.  May expand *EXPP.  The CONTEXT_TYPE functions
+/* Resolve the operator of the subexpression beginning at position
+   *POS of *EXPP.  "Resolving" consists of replacing the symbols that
+   have undefined namespaces in OP_VAR_VALUE nodes with their
+   resolutions, replacing built-in operators with function calls to
+   user-defined operators, where appropriate, and, when DEPROCEDURE_P
+   is non-zero, converting function-valued variables into
+   parameterless calls.  May expand *EXPP.  The CONTEXT_TYPE functions
    are as in ada_resolve, above.  */
 
 static struct value *
@@ -3021,14 +3022,14 @@ resolve_subexp (struct expression **expp
           n_candidates =
             ada_lookup_symbol_list (SYMBOL_LINKAGE_NAME
                                     (exp->elts[pc + 2].symbol),
-                                    exp->elts[pc + 1].block, VAR_DOMAIN,
-                                    &candidates);
+                                    exp->elts[pc + 1].block,
+                                    VAR_DOMAIN, &candidates);
 
           if (n_candidates > 1)
             {
               /* Types tend to get re-introduced locally, so if there
-                 are any local symbols that are not types, first filter
-                 out all types.  */
+                 are any local symbols that are not types, first
+                 filter out all types.  */
               int j;
               for (j = 0; j < n_candidates; j += 1)
                 switch (SYMBOL_CLASS (candidates[j].sym))
@@ -3113,8 +3114,8 @@ resolve_subexp (struct expression **expp
             n_candidates =
               ada_lookup_symbol_list (SYMBOL_LINKAGE_NAME
                                       (exp->elts[pc + 5].symbol),
-                                      exp->elts[pc + 4].block, VAR_DOMAIN,
-                                      &candidates);
+                                      exp->elts[pc + 4].block,
+                                      VAR_DOMAIN, &candidates);
             if (n_candidates == 1)
               i = 0;
             else
@@ -3167,13 +3168,13 @@ resolve_subexp (struct expression **expp
             ada_lookup_symbol_list (ada_encode (ada_decoded_op_name (op)),
                                     (struct block *) NULL, VAR_DOMAIN,
                                     &candidates);
-          i = ada_resolve_function (candidates, n_candidates, argvec, nargs,
-                                    ada_decoded_op_name (op), NULL);
+          i = ada_resolve_function (candidates, n_candidates, argvec,
+                                    nargs, ada_decoded_op_name (op), NULL);
           if (i < 0)
             break;
 
-          replace_operator_with_call (expp, pc, nargs, 1,
-                                      candidates[i].sym, candidates[i].block);
+          replace_operator_with_call (expp, pc, nargs, 1, candidates[i].sym,
+                                      candidates[i].block);
           exp = *expp;
         }
       break;
@@ -3314,17 +3315,17 @@ return_match (struct type *func_type, st
 }
 
 
-/* Returns the index in SYMS[0..NSYMS-1] that contains  the symbol for the
-   function (if any) that matches the types of the NARGS arguments in
-   ARGS.  If CONTEXT_TYPE is non-null and there is at least one match
-   that returns that type, then eliminate matches that don't.  If
-   CONTEXT_TYPE is void and there is at least one match that does not
-   return void, eliminate all matches that do.
-
-   Asks the user if there is more than one match remaining.  Returns -1
-   if there is no such symbol or none is selected.  NAME is used
-   solely for messages.  May re-arrange and modify SYMS in
-   the process; the index returned is for the modified vector.  */
+/* Returns the index in SYMS[0..NSYMS-1] that contains the symbol for
+   the function (if any) that matches the types of the NARGS arguments
+   in ARGS.  If CONTEXT_TYPE is non-null and there is at least one
+   match that returns that type, then eliminate matches that don't.
+   If CONTEXT_TYPE is void and there is at least one match that does
+   not return void, eliminate all matches that do.
+
+   Asks the user if there is more than one match remaining.  Returns
+   -1 if there is no such symbol or none is selected.  NAME is used
+   solely for messages.  May re-arrange and modify SYMS in the
+   process; the index returned is for the modified vector.  */
 
 static int
 ada_resolve_function (struct ada_symbol_info syms[],
@@ -3337,8 +3338,8 @@ ada_resolve_function (struct ada_symbol_
 
   m = 0;
   /* In the first pass of the loop, we only accept functions matching
-     context_type.  If none are found, we add a second pass of the loop
-     where every function is accepted.  */
+     context_type.  If none are found, we add a second pass of the
+     loop where every function is accepted.  */
   for (fallback = 0; m == 0 && fallback < 2; fallback++)
     {
       for (k = 0; k < nsyms; k += 1)
@@ -3366,10 +3367,10 @@ ada_resolve_function (struct ada_symbol_
 }
 
 /* Returns true (non-zero) iff decoded name N0 should appear before N1
-   in a listing of choices during disambiguation (see sort_choices, below).
-   The idea is that overloadings of a subprogram name from the
-   same package should sort in their source order.  We settle for ordering
-   such symbols by their trailing number (__N  or $N).  */
+   in a listing of choices during disambiguation (see sort_choices,
+   below).  The idea is that overloadings of a subprogram name from
+   the same package should sort in their source order.  We settle for
+   ordering such symbols by their trailing number (__N or $N).  */
 
 static int
 encoded_ordered_before (char *N0, char *N1)
@@ -3404,8 +3405,8 @@ encoded_ordered_before (char *N0, char *
     }
 }
 
-/* Sort SYMS[0..NSYMS-1] to put the choices in a canonical order by the
-   encoded names.  */
+/* Sort SYMS[0..NSYMS-1] to put the choices in a canonical order by
+   the encoded names.  */
 
 static void
 sort_choices (struct ada_symbol_info syms[], int nsyms)
@@ -3428,7 +3429,7 @@ sort_choices (struct ada_symbol_info sym
     }
 }
 
-/* Given a list of NSYMS symbols in SYMS, select up to MAX_RESULTS>0 
+/* Given a list of NSYMS symbols in SYMS, select up to MAX_RESULTS>0
    by asking the user (if necessary), returning the number selected, 
    and setting the first elements of SYMS items.  Error if no symbols
    selected.  */
@@ -3624,17 +3625,17 @@ get_selections (int *choices, int n_choi
   return n_chosen;
 }
 
-/* Replace the operator of length OPLEN at position PC in *EXPP with a call
-   on the function identified by SYM and BLOCK, and taking NARGS
+/* Replace the operator of length OPLEN at position PC in *EXPP with a
+   call on the function identified by SYM and BLOCK, and taking NARGS
    arguments.  Update *EXPP as needed to hold more space.  */
 
 static void
-replace_operator_with_call (struct expression **expp, int pc, int nargs,
-                            int oplen, struct symbol *sym,
+replace_operator_with_call (struct expression **expp, int pc,
+                            int nargs, int oplen, struct symbol *sym,
                             struct block *block)
 {
-  /* A new expression, with 6 more elements (3 for funcall, 4 for function
-     symbol, -oplen for operator being replaced).  */
+  /* A new expression, with 6 more elements (3 for funcall, 4 for
+     function symbol, -oplen for operator being replaced).  */
   struct expression *newexp = (struct expression *)
     xmalloc (sizeof (struct expression)
              + EXP_ELEM_TO_BYTES ((*expp)->nelts + 7 - oplen));
@@ -3824,8 +3825,8 @@ possible_user_operator_p (enum exp_opcod
        <renaming> renames <renamed entity>,
 
    sets *LEN to the length of the renamed entity's name,
-   *RENAMED_ENTITY to that name (not null-terminated), and *RENAMING_EXPR to
-   the string describing the subcomponent selected from the renamed
+   *RENAMED_ENTITY to that name (not null-terminated), and *RENAMING_EXPR
+   to the string describing the subcomponent selected from the renamed
    entity.  Returns ADA_NOT_RENAMING if SYM does not encode a renaming
    (in which case, the values of *RENAMED_ENTITY, *LEN, and *RENAMING_EXPR
    are undefined).  Otherwise, returns a value indicating the category
@@ -3854,8 +3855,8 @@ ada_parse_renaming (struct symbol *sym,
     default:
       return ADA_NOT_RENAMING;
     case LOC_TYPEDEF:
-      return parse_old_style_renaming (SYMBOL_TYPE (sym), 
-				       renamed_entity, len, renaming_expr);
+      return parse_old_style_renaming (SYMBOL_TYPE (sym), renamed_entity,
+				       len, renaming_expr);
     case LOC_LOCAL:
     case LOC_STATIC:
     case LOC_COMPUTED:
@@ -4037,10 +4038,10 @@ ada_convert_actual (struct value *actual
   return actual;
 }
 
-/* Convert VALUE (which must be an address) to a CORE_ADDR that is a pointer of
-   type TYPE.  This is usually an inefficient no-op except on some targets
-   (such as AVR) where the representation of a pointer and an address
-   differs.  */
+/* Convert VALUE (which must be an address) to a CORE_ADDR that is a
+   pointer of type TYPE.  This is usually an inefficient no-op except
+   on some targets (such as AVR) where the representation of a pointer
+   and an address differs.  */
 
 static CORE_ADDR
 value_pointer (struct value *value, struct type *type)
@@ -4120,8 +4121,8 @@ lookup_cached_symbol (const char *name, 
 }
 
 static void
-cache_symbol (const char *name, domain_enum namespace, struct symbol *sym,
-              struct block *block)
+cache_symbol (const char *name, domain_enum namespace,
+              struct symbol *sym, struct block *block)
 {
 }
 
@@ -4145,8 +4146,8 @@ standard_lookup (const char *name, const
 
 
 /* Non-zero iff there is at least one non-function/non-enumeral symbol
-   in the symbol fields of SYMS[0..N-1].  We treat enumerals as functions, 
-   since they contend in overloading in the same way.  */
+   in the symbol fields of SYMS[0..N-1].  We treat enumerals as
+   functions, since they contend in overloading in the same way.  */
 static int
 is_nonfunction (struct ada_symbol_info syms[], int n)
 {
@@ -4320,8 +4321,8 @@ ada_lookup_simple_minsym (const char *na
 
 static void
 add_symbols_from_enclosing_procs (struct obstack *obstackp,
-                                  const char *name, domain_enum namespace,
-                                  int wild_match)
+                                  const char *name,
+                                  domain_enum namespace, int wild_match)
 {
 }
 
@@ -4353,8 +4354,8 @@ remove_extra_symbols (struct ada_symbol_
     {
       int remove = 0;
 
-      /* If two symbols have the same name and one of them is a stub type,
-         the get rid of the stub.  */
+      /* If two symbols have the same name and one of them is a stub
+         type, the get rid of the stub.  */
 
       if (TYPE_STUB (SYMBOL_TYPE (syms[i].sym))
           && SYMBOL_LINKAGE_NAME (syms[i].sym) != NULL)
@@ -4460,8 +4461,8 @@ is_package_name (const char *name)
   /* Library-level function names start with "_ada_".  See if function
      "_ada_" followed by NAME can be found.  */
 
-  /* Do a quick check that NAME does not contain "__", since library-level
-     functions names cannot contain "__" in them.  */
+  /* Do a quick check that NAME does not contain "__", since
+     library-level functions names cannot contain "__" in them.  */
   if (strstr (name, "__") != NULL)
     return 0;
 
@@ -4514,13 +4515,14 @@ old_renaming_is_invisible (const struct 
    variable and the renaming encoding.  In this case, we discard the
    latter.
 
-   Second, GNAT emits a type following a specified encoding for each renaming
-   entity.  Unfortunately, STABS currently does not support the definition
-   of types that are local to a given lexical block, so all renamings types
-   are emitted at library level.  As a consequence, if an application
-   contains two renaming entities using the same name, and a user tries to
-   print the value of one of these entities, the result of the ada symbol
-   lookup will also contain the wrong renaming type.
+   Second, GNAT emits a type following a specified encoding for each
+   renaming entity.  Unfortunately, STABS currently does not support
+   the definition of types that are local to a given lexical block, so
+   all renamings types are emitted at library level.  As a
+   consequence, if an application contains two renaming entities using
+   the same name, and a user tries to print the value of one of these
+   entities, the result of the ada symbol lookup will also contain the
+   wrong renaming type.
 
    This function partially covers for this limitation by attempting to
    remove from the SYMS list renaming symbols that should be visible
@@ -4531,8 +4533,8 @@ old_renaming_is_invisible (const struct 
       - When the user tries to print a rename in a function while there
         is another rename entity defined in a package:  Normally, the
         rename in the function has precedence over the rename in the
-        package, so the latter should be removed from the list.  This is
-        currently not the case.
+        package, so the latter should be removed from the list.  This
+        is currently not the case.
         
       - This function will incorrectly remove valid renames if
         the CURRENT_BLOCK corresponds to a function which symbol name
@@ -4540,8 +4542,8 @@ old_renaming_is_invisible (const struct 
         the user will be unable to print such rename entities.  */
 
 static int
-remove_irrelevant_renamings (struct ada_symbol_info *syms,
-			     int nsyms, const struct block *current_block)
+remove_irrelevant_renamings (struct ada_symbol_info *syms, int nsyms,
+			     const struct block *current_block)
 {
   struct symbol *current_function;
   char *current_function_name;
@@ -4657,8 +4659,8 @@ ada_add_local_symbols (struct obstack *o
       block = BLOCK_SUPERBLOCK (block);
     }
 
-  /* If no luck so far, try to find NAME as a local symbol in some lexically
-     enclosing subprogram.  */
+  /* If no luck so far, try to find NAME as a local symbol in some
+     lexically enclosing subprogram.  */
   if (num_defns_collected (obstackp) == 0 && block_depth > 2)
     add_symbols_from_enclosing_procs (obstackp, name, domain, wild_match);
 }
@@ -4676,9 +4678,9 @@ struct match_data
 
 /* A callback for add_matching_symbols that adds SYM, found in BLOCK,
    to a list of symbols.  DATA0 is a pointer to a struct match_data *
-   containing the obstack that collects the symbol list, the file that SYM
-   must come from, a flag indicating whether a non-argument symbol has
-   been found in the current block, and the last argument symbol
+   containing the obstack that collects the symbol list, the file that
+   SYM must come from, a flag indicating whether a non-argument symbol
+   has been found in the current block, and the last argument symbol
    passed in SYM within the current block (if any).  When SYM is null,
    marking the end of a block, the argument symbol is added if no
    other has been found.  */
@@ -4772,8 +4774,8 @@ add_nonlocal_symbols (struct obstack *ob
 
       if (is_wild_match)
 	objfile->sf->qf->map_matching_symbols (name, domain, objfile, global,
-					       aux_add_nonlocal_symbols, &data,
-					       wild_match, NULL);
+					       aux_add_nonlocal_symbols,
+					       &data, wild_match, NULL);
       else
 	objfile->sf->qf->map_matching_symbols (name, domain, objfile, global,
 					       aux_add_nonlocal_symbols, &data,
@@ -4791,25 +4793,26 @@ add_nonlocal_symbols (struct obstack *ob
 	  objfile->sf->qf->map_matching_symbols (name1, domain,
 						 objfile, global,
 						 aux_add_nonlocal_symbols,
-						 &data,
-						 full_match, compare_names);
+						 &data, full_match,
+						 compare_names);
 	}
     }      	
 }
 
 /* Find symbols in DOMAIN matching NAME0, in BLOCK0 and enclosing
    scope and in global scopes, returning the number of matches.  Sets
-   *RESULTS to point to a vector of (SYM,BLOCK) tuples,
-   indicating the symbols found and the blocks and symbol tables (if
-   any) in which they were found.  This vector are transient---good only to 
-   the next call of ada_lookup_symbol_list.  Any non-function/non-enumeral 
-   symbol match within the nest of blocks whose innermost member is BLOCK0,
-   is the one match returned (no other matches in that or
-     enclosing blocks is returned).  If there are any matches in or
+   *RESULTS to point to a vector of (SYM,BLOCK) tuples, indicating the
+   symbols found and the blocks and symbol tables (if any) in which
+   they were found.  This vector are transient---good only to the next
+   call of ada_lookup_symbol_list.  Any non-function/non-enumeral
+   symbol match within the nest of blocks whose innermost member is
+   BLOCK0, is the one match returned (no other matches in that or
+   enclosing blocks is returned).  If there are any matches in or
    surrounding BLOCK0, then these alone are returned.  Otherwise, the
    search extends to global and file-scope (static) symbol tables.
-   Names prefixed with "standard__" are handled specially: "standard__" 
-   is first stripped off, and only static and global symbols are searched.  */
+   Names prefixed with "standard__" are handled specially:
+   "standard__" is first stripped off, and only static and global
+   symbols are searched.  */
 
 int
 ada_lookup_symbol_list (const char *name0, const struct block *block0,
@@ -4946,8 +4949,8 @@ ada_lookup_symbol_nonlocal (const char *
 
 /* True iff STR is a possible encoded suffix of a normal Ada name
    that is to be ignored for matching purposes.  Suffixes of parallel
-   names (e.g., XVE) are not included here.  Currently, the possible suffixes
-   are given by any of the regular expressions:
+   names (e.g., XVE) are not included here.  Currently, the possible
+   suffixes are given by any of the regular expressions:
 
    [.$][0-9]+       [nested subprogram suffix, on platforms such as GNU/Linux]
    ___[0-9]+        [nested subprogram suffix, on platforms such as HP/UX]
@@ -4999,15 +5002,15 @@ is_name_suffix (const char *str)
 #if 0
   /* FIXME: brobecker/2005-09-23: Protected Object subprograms end
      with a N at the end.  Unfortunately, the compiler uses the same
-     convention for other internal types it creates.  So treating
-     all entity names that end with an "N" as a name suffix causes
-     some regressions.  For instance, consider the case of an enumerated
+     convention for other internal types it creates.  So treating all
+     entity names that end with an "N" as a name suffix causes some
+     regressions.  For instance, consider the case of an enumerated
      type.  To support the 'Image attribute, it creates an array whose
      name ends with N.
      Having a single character like this as a suffix carrying some
-     information is a bit risky.  Perhaps we should change the encoding
-     to be something like "_N" instead.  In the meantime, do not do
-     the following check.  */
+     information is a bit risky.  Perhaps we should change the
+     encoding to be something like "_N" instead.  In the meantime, do
+     not do the following check.  */
   /* Protected Object Subprograms */
   if (len == 1 && str [0] == 'N')
     return 1;
@@ -5150,9 +5153,9 @@ advance_wild_match (const char **namep, 
   return 1;
 }
 
-/* Return 0 iff NAME encodes a name of the form prefix.PATN.  Ignores any
-   informational suffixes of NAME (i.e., for which is_name_suffix is
-   true).  Assumes that PATN is a lower-cased Ada simple name.  */
+/* Return 0 iff NAME encodes a name of the form prefix.PATN.  Ignores
+   any informational suffixes of NAME (i.e., for which is_name_suffix
+   is true).  Assumes that PATN is a lower-cased Ada simple name.  */
 
 static int
 wild_match (const char *name, const char *patn)
@@ -5483,8 +5486,8 @@ ada_add_partial_symbol_completions (cons
 {
   struct add_partial_datum *data = user_data;
 
-  symbol_completion_add (data->completions, name,
-			 data->text, data->text_len, data->text0, data->word,
+  symbol_completion_add (data->completions, name, data->text,
+			 data->text_len, data->text0, data->word,
 			 data->wild_match, data->encoded);
 }
 
@@ -5626,8 +5629,8 @@ ada_make_symbol_completion_list (char *t
 
                                 /* Field Access */
 
-/* Return non-zero if TYPE is a pointer to the GNAT dispatch table used
-   for tagged types.  */
+/* Return non-zero if TYPE is a pointer to the GNAT dispatch table
+   used for tagged types.  */
 
 static int
 ada_is_dispatch_table_ptr_type (struct type *type)
@@ -5644,8 +5647,8 @@ ada_is_dispatch_table_ptr_type (struct t
   return (strcmp (name, "ada__tags__dispatch_table") == 0);
 }
 
-/* True if field number FIELD_NUM in struct or union type TYPE is supposed
-   to be invisible to users.  */
+/* True if field number FIELD_NUM in struct or union type TYPE is
+   supposed to be invisible to users.  */
 
 int
 ada_is_ignored_field (struct type *type, int field_num)
@@ -5658,8 +5661,8 @@ ada_is_ignored_field (struct type *type,
     const char *name = TYPE_FIELD_NAME (type, field_num);
 
     /* Anonymous field names should not be printed.
-       brobecker/2007-02-20: I don't think this can actually happen
-       but we don't want to print the value of annonymous fields anyway.  */
+       brobecker/2007-02-20: I don't think this can actually happen but
+       we don't want to print the value of annonymous fields anyway.  */
     if (name == NULL)
       return 1;
 
@@ -5731,8 +5734,8 @@ value_tag_from_contents_and_address (str
   int tag_byte_offset;
   struct type *tag_type;
 
-  if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
-                         NULL, NULL, NULL))
+  if (find_struct_field ("_tag", type, 0, &tag_type,
+                         &tag_byte_offset, NULL, NULL, NULL))
     {
       const gdb_byte *valaddr1 = ((valaddr == NULL)
 				  ? NULL
@@ -5899,10 +5902,10 @@ ada_is_parent_field (struct type *type, 
 }
 
 /* True iff field number FIELD_NUM of structure type TYPE is a
-   transparent wrapper field (which should be silently traversed when doing
-   field selection and flattened when printing).  Assumes TYPE is a
-   structure type with at least FIELD_NUM+1 fields.  Such fields are always
-   structures.  */
+   transparent wrapper field (which should be silently traversed when
+   doing field selection and flattened when printing).  Assumes TYPE
+   is a structure type with at least FIELD_NUM+1 fields.  Such fields
+   are always structures.  */
 
 int
 ada_is_wrapper_field (struct type *type, int field_num)
@@ -5916,8 +5919,8 @@ ada_is_wrapper_field (struct type *type,
               || name[0] == 'S' || name[0] == 'R' || name[0] == 'O'));
 }
 
-/* True iff field number FIELD_NUM of structure or union type TYPE
-   is a variant wrapper.  Assumes TYPE is a structure type with at least
+/* True iff field number FIELD_NUM of structure or union type TYPE is
+   a variant wrapper.  Assumes TYPE is a structure type with at least
    FIELD_NUM+1 fields.  */
 
 int
@@ -5931,10 +5934,10 @@ ada_is_variant_part (struct type *type, 
 		  == TYPE_CODE_UNION)));
 }
 
-/* Assuming that VAR_TYPE is a variant wrapper (type of the variant part)
-   whose discriminants are contained in the record type OUTER_TYPE,
-   returns the type of the controlling discriminant for the variant.
-   May return NULL if the type could not be found.  */
+/* Assuming that VAR_TYPE is a variant wrapper (type of the variant
+   part) whose discriminants are contained in the record type
+   OUTER_TYPE, returns the type of the controlling discriminant for
+   the variant.  May return NULL if the type could not be found.  */
 
 struct type *
 ada_variant_discrim_type (struct type *var_type, struct type *outer_type)
@@ -5944,9 +5947,9 @@ ada_variant_discrim_type (struct type *v
   return ada_lookup_struct_elt_type (outer_type, name, 1, 1, NULL);
 }
 
-/* Assuming that TYPE is the type of a variant wrapper, and FIELD_NUM is a
-   valid field number within it, returns 1 iff field FIELD_NUM of TYPE
-   represents a 'when others' clause; otherwise 0.  */
+/* Assuming that TYPE is the type of a variant wrapper, and FIELD_NUM
+   is a valid field number within it, returns 1 iff field FIELD_NUM of
+   TYPE represents a 'when others' clause; otherwise 0.  */
 
 int
 ada_is_others_clause (struct type *type, int field_num)
@@ -5957,8 +5960,8 @@ ada_is_others_clause (struct type *type,
 }
 
 /* Assuming that TYPE0 is the type of the variant part of a record,
-   returns the name of the discriminant controlling the variant.
-   The value is valid until the next call to ada_variant_discrim_name.  */
+   returns the name of the discriminant controlling the variant.  The
+   value is valid until the next call to ada_variant_discrim_name.  */
 
 char *
 ada_variant_discrim_name (struct type *type0)
@@ -6010,9 +6013,9 @@ ada_variant_discrim_name (struct type *t
    Put the position of the character just past the number scanned in
    *NEW_K, if NEW_K!=NULL.  Put the scanned number in *R, if R!=NULL.
    Return 1 if there was a valid number at the given position, and 0
-   otherwise.  A "subtype-encoded" number consists of the absolute value
-   in decimal, followed by the letter 'm' to indicate a negative number.
-   Assumes 0m does not occur.  */
+   otherwise.  A "subtype-encoded" number consists of the absolute
+   value in decimal, followed by the letter 'm' to indicate a negative
+   number.  Assumes 0m does not occur.  */
 
 int
 ada_scan_number (const char str[], int k, LONGEST * R, int *new_k)
@@ -6041,11 +6044,11 @@ ada_scan_number (const char str[], int k
   else if (R != NULL)
     *R = (LONGEST) RU;
 
-  /* NOTE on the above: Technically, C does not say what the results of
-     - (LONGEST) RU or (LONGEST) -RU are for RU == largest positive
-     number representable as a LONGEST (although either would probably work
-     in most implementations).  When RU>0, the locution in the then branch
-     above is always equivalent to the negative of RU.  */
+  /* NOTE on the above: Technically, C does not say what the results
+     of - (LONGEST) RU or (LONGEST) -RU are for RU == largest positive
+     number representable as a LONGEST (although either would probably
+     work in most implementations).  When RU>0, the locution in the
+     then branch above is always equivalent to the negative of RU.  */
 
   if (new_k != NULL)
     *new_k = k;
@@ -6053,8 +6056,8 @@ ada_scan_number (const char str[], int k
 }
 
 /* Assuming that TYPE is a variant part wrapper type (a VARIANTS field),
-   and FIELD_NUM is a valid field number within it, returns 1 iff VAL is
-   in the range encoded by field FIELD_NUM of TYPE; otherwise 0.  */
+   and FIELD_NUM is a valid field number within it, returns 1 iff VAL
+   is in the range encoded by field FIELD_NUM of TYPE; otherwise 0.  */
 
 int
 ada_in_variant (LONGEST val, struct type *type, int field_num)
@@ -6083,8 +6086,8 @@ ada_in_variant (LONGEST val, struct type
           {
             LONGEST L, U;
 
-            if (!ada_scan_number (name, p + 1, &L, &p)
-                || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
+            if (!ada_scan_number (name, p + 1, &L, &p) || name[p] != 'T' ||
+		!ada_scan_number (name, p + 1, &U, &p))
               return 0;
             if (val >= L && val <= U)
               return 1;
@@ -6106,8 +6109,8 @@ ada_in_variant (LONGEST val, struct type
    only in that it can handle packed values of arbitrary type.  */
 
 static struct value *
-ada_value_primitive_field (struct value *arg1, int offset, int fieldno,
-                           struct type *arg_type)
+ada_value_primitive_field (struct value *arg1, int offset,
+                           int fieldno, struct type *arg_type)
 {
   struct type *type;
 
@@ -6146,8 +6149,8 @@ ada_value_primitive_field (struct value 
 
 static int
 find_struct_field (char *name, struct type *type, int offset,
-                   struct type **field_type_p,
-                   int *byte_offset_p, int *bit_offset_p, int *bit_size_p,
+                   struct type **field_type_p, int *byte_offset_p,
+                   int *bit_offset_p, int *bit_size_p,
 		   int *index_p)
 {
   int i;
@@ -6195,8 +6198,8 @@ find_struct_field (char *name, struct ty
         }
       else if (ada_is_variant_part (type, i))
         {
-	  /* PNH: Wait.  Do we ever execute this section, or is ARG always of 
-	     fixed type?? */
+	  /* PNH: Wait.  Do we ever execute this section, or is ARG
+	     always of fixed type?? */
           int j;
           struct type *field_type
 	    = ada_check_typedef (TYPE_FIELD_TYPE (type, i));
@@ -6229,9 +6232,9 @@ num_visible_fields (struct type *type)
   return n;
 }
 
-/* Look for a field NAME in ARG.  Adjust the address of ARG by OFFSET bytes,
-   and search in it assuming it has (class) type TYPE.
-   If found, return value, else return NULL.
+/* Look for a field NAME in ARG.  Adjust the address of ARG by OFFSET
+   bytes, and search in it assuming it has (class) type TYPE.  If
+   found, return value, else return NULL.
 
    Searches recursively through wrapper fields (e.g., '_parent').  */
 
@@ -6292,9 +6295,9 @@ static struct value *ada_index_struct_fi
 
 
 /* Return field #INDEX in ARG, where the index is that returned by
- * find_struct_field through its INDEX_P argument.  Adjust the address
- * of ARG by OFFSET bytes, and search in it assuming it has (class) type TYPE.
- * If found, return value, else return NULL.  */
+   find_struct_field through its INDEX_P argument.  Adjust the address
+   of ARG by OFFSET bytes, and search in it assuming it has (class)
+   type TYPE.  If found, return value, else return NULL.  */
 
 static struct value *
 ada_index_struct_field (int index, struct value *arg, int offset,
@@ -6349,8 +6352,8 @@ ada_index_struct_field_1 (int *index_p, 
    target structure/union and return it as a value with its
    appropriate type.
 
-   The routine searches for NAME among all members of the structure itself
-   and (recursively) among all members of any wrapper members
+   The routine searches for NAME among all members of the structure
+   itself and (recursively) among all members of any wrapper members
    (e.g., '_parent').
 
    If NO_ERR, then simply return NULL in case of error, rather than 
@@ -6441,10 +6444,10 @@ ada_value_struct_elt (struct value *arg,
 	     "a value that is not a record."));
 }
 
-/* Given a type TYPE, look up the type of the component of type named NAME.
-   If DISPP is non-null, add its byte displacement from the beginning of a
-   structure (pointed to by a value) of type TYPE to *DISPP (does not
-   work for packed fields).
+/* Given a type TYPE, look up the type of the component of type named
+   NAME.  If DISPP is non-null, add its byte displacement from the
+   beginning of a structure (pointed to by a value) of type TYPE to
+   *DISPP (does not work for packed fields).
 
    Matches any field whose name has NAME as a prefix, possibly
    followed by "___".
@@ -6459,8 +6462,8 @@ ada_value_struct_elt (struct value *arg,
    TYPE is not a type of the right kind.  */
 
 static struct type *
-ada_lookup_struct_elt_type (struct type *type, char *name, int refok,
-                            int noerr, int *dispp)
+ada_lookup_struct_elt_type (struct type *type, char *name,
+                            int refok, int noerr, int *dispp)
 {
   int i;
 
@@ -6520,8 +6523,8 @@ ada_lookup_struct_elt_type (struct type 
       else if (ada_is_wrapper_field (type, i))
         {
           disp = 0;
-          t = ada_lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name,
-                                          0, 1, &disp);
+          t = ada_lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i),
+                                          name, 0, 1, &disp);
           if (t != NULL)
             {
               if (dispp != NULL)
@@ -6533,8 +6536,8 @@ ada_lookup_struct_elt_type (struct type 
       else if (ada_is_variant_part (type, i))
         {
           int j;
-          struct type *field_type = ada_check_typedef (TYPE_FIELD_TYPE (type,
-									i));
+          struct type *field_type
+	    = ada_check_typedef (TYPE_FIELD_TYPE (type, i));
 
           for (j = TYPE_NFIELDS (field_type) - 1; j >= 0; j -= 1)
             {
@@ -6587,8 +6590,8 @@ BadName:
   return NULL;
 }
 
-/* Assuming that VAR_TYPE is the type of a variant part of a record (a union),
-   within a value of type OUTER_TYPE, return true iff VAR_TYPE
+/* Assuming that VAR_TYPE is the type of a variant part of a record (a
+   union), within a value of type OUTER_TYPE, return true iff VAR_TYPE
    represents an unchecked union (that is, the variant part of a
    record that is named in an Unchecked_Union pragma).  */
 
@@ -6597,15 +6600,15 @@ is_unchecked_variant (struct type *var_t
 {
   char *discrim_name = ada_variant_discrim_name (var_type);
 
-  return (ada_lookup_struct_elt_type (outer_type, discrim_name, 0, 1, NULL) 
-	  == NULL);
+  return (ada_lookup_struct_elt_type (outer_type, discrim_name,
+				      0, 1, NULL)  == NULL);
 }
 
 
-/* Assuming that VAR_TYPE is the type of a variant part of a record (a union),
-   within a value of type OUTER_TYPE that is stored in GDB at
-   OUTER_VALADDR, determine which variant clause (field number in VAR_TYPE,
-   numbering from 0) is applicable.  Returns -1 if none are.  */
+/* Assuming that VAR_TYPE is the type of a variant part of a record (a
+   union), within a value of type OUTER_TYPE that is stored in GDB at
+   OUTER_VALADDR, determine which variant clause (field number in
+   VAR_TYPE, numbering from 0) is applicable.  Returns -1 if none are.  */
 
 int
 ada_which_variant_applies (struct type *var_type, struct type *outer_type,
@@ -6656,10 +6659,10 @@ ada_which_variant_applies (struct type *
    rather than struct value*s.
 
    However, GDB's internal history variables ($1, $2, etc.) are
-   struct value*s containing internal copies of the data that are not, in
-   general, the same as the data at their corresponding addresses in
-   the target.  Fortunately, the types we give to these values are all
-   conventional, fixed-size types (as per the strategy described
+   struct value*s containing internal copies of the data that are not,
+   in general, the same as the data at their corresponding addresses
+   in the target.  Fortunately, the types we give to these values are
+   all conventional, fixed-size types (as per the strategy described
    above), so that we don't usually have to perform the
    'to_fixed_xxx_type' conversions to look at their values.
    Unfortunately, there is one exception: if one of the internal
@@ -6721,9 +6724,9 @@ field_alignment (struct type *type, int 
   int len;
   int align_offset;
 
-  /* The field name should never be null, unless the debugging information
-     is somehow malformed.  In this case, we assume the field does not
-     require any alignment.  */
+  /* The field name should never be null, unless the debugging
+     information is somehow malformed.  In this case, we assume the
+     field does not require any alignment.  */
   if (name == NULL)
     return 1;
 
@@ -6836,8 +6839,8 @@ find_old_style_renaming_symbol (const ch
 
       rename = (char *) alloca (rename_len * sizeof (char));
       strncpy (rename, function_name, function_name_len);
-      xsnprintf (rename + function_name_len, rename_len - function_name_len,
-		 "__%s___XR", name);
+      xsnprintf (rename + function_name_len,
+		 rename_len - function_name_len, "__%s___XR", name);
     }
   else
     {
@@ -6850,9 +6853,9 @@ find_old_style_renaming_symbol (const ch
   return ada_find_any_symbol (rename);
 }
 
-/* Because of GNAT encoding conventions, several GDB symbols may match a
-   given type name.  If the type denoted by TYPE0 is to be preferred to
-   that of TYPE1 for purposes of type printing, return non-zero;
+/* Because of GNAT encoding conventions, several GDB symbols may match
+   a given type name.  If the type denoted by TYPE0 is to be preferred
+   to that of TYPE1 for purposes of type printing, return non-zero;
    otherwise return 0.  */
 
 int
@@ -6983,8 +6986,8 @@ ada_find_parallel_type (struct type *typ
   return ada_find_parallel_type_with_name (type, name);
 }
 
-/* If TYPE is a variable-size record type, return the corresponding template
-   type describing its fields.  Otherwise, return NULL.  */
+/* If TYPE is a variable-size record type, return the corresponding
+   template type describing its fields.  Otherwise, return NULL.  */
 
 static struct type *
 dynamic_template_type (struct type *type)
@@ -7147,11 +7150,11 @@ ada_template_to_fixed_record_type_1 (str
           else
             dval = dval0;
 
-	  /* If the type referenced by this field is an aligner type, we need
-	     to unwrap that aligner type, because its size might not be set.
-	     Keeping the aligner type would cause us to compute the wrong
-	     size for this field, impacting the offset of the all the fields
-	     that follow this one.  */
+	  /* If the type referenced by this field is an aligner type,
+	     we need to unwrap that aligner type, because its size
+	     might not be set.  Keeping the aligner type would cause
+	     us to compute the wrong size for this field, impacting
+	     the offset of the all the fields that follow this one.  */
 	  if (ada_is_aligner_type (field_type))
 	    {
 	      long field_offset = TYPE_FIELD_BITPOS (field_type, f);
@@ -7202,9 +7205,9 @@ ada_template_to_fixed_record_type_1 (str
 	  /* If our field is a typedef type (most likely a typedef of
 	     a fat pointer, encoding an array access), then we need to
 	     look at its target type to determine its characteristics.
-	     In particular, we would miscompute the field size if we took
-	     the size of the typedef (zero), instead of the size of
-	     the target type.  */
+	     In particular, we would miscompute the field size if we
+	     took the size of the typedef (zero), instead of the size
+	     of the target type.  */
 	  if (TYPE_CODE (field_type) == TYPE_CODE_TYPEDEF)
 	    field_type = ada_typedef_target_type (field_type);
 
@@ -7225,9 +7228,9 @@ ada_template_to_fixed_record_type_1 (str
     }
 
   /* We handle the variant part, if any, at the end because of certain
-     odd cases in which it is re-ordered so as NOT to be the last field of
-     the record.  This can happen in the presence of representation
-     clauses.  */
+     odd cases in which it is re-ordered so as NOT to be the last
+     field of the record.  This can happen in the presence of
+     representation clauses.  */
   if (variant_field >= 0)
     {
       struct type *branch_type;
@@ -7303,12 +7306,12 @@ template_to_fixed_record_type (struct ty
 }
 
 /* An ordinary record type in which ___XVL-convention fields and
-   ___XVU- and ___XVN-convention field types in TYPE0 are replaced with
-   static approximations, containing all possible fields.  Uses
-   no runtime values.  Useless for use in values, but that's OK,
-   since the results are used only for type determinations.   Works on both
-   structs and unions.  Representation note: to save space, we memorize
-   the result of this function in the TYPE_TARGET_TYPE of the
+   ___XVU- and ___XVN-convention field types in TYPE0 are replaced
+   with static approximations, containing all possible fields.  Uses
+   no runtime values.  Useless for use in values, but that's OK, since
+   the results are used only for type determinations.  Works on both
+   structs and unions.  Representation note: to save space, we
+   memorize the result of this function in the TYPE_TARGET_TYPE of the
    template type.  */
 
 static struct type *
@@ -7543,17 +7546,17 @@ to_fixed_array_type (struct type *type0,
     {
       struct type *elt_type0 = ada_check_typedef (TYPE_TARGET_TYPE (type0));
 
-      /* NOTE: elt_type---the fixed version of elt_type0---should never
-         depend on the contents of the array in properly constructed
-         debugging data.  */
-      /* Create a fixed version of the array element type.
-         We're not providing the address of an element here,
-         and thus the actual object value cannot be inspected to do
-         the conversion.  This should not be a problem, since arrays of
-         unconstrained objects are not allowed.  In particular, all
-         the elements of an array of a tagged type should all be of
-         the same type specified in the debugging info.  No need to
-         consult the object tag.  */
+      /* NOTE: elt_type---the fixed version of elt_type0---should
+         never depend on the contents of the array in properly
+         constructed debugging data.  */
+      /* Create a fixed version of the array element type.  We're not
+         providing the address of an element here, and thus the actual
+         object value cannot be inspected to do the conversion.  This
+         should not be a problem, since arrays of unconstrained
+         objects are not allowed.  In particular, all the elements of
+         an array of a tagged type should all be of the same type
+         specified in the debugging info.  No need to consult the
+         object tag.  */
       struct type *elt_type = ada_to_fixed_type (elt_type0, 0, 0, dval, 1);
 
       /* Make sure we always create a new array type when dealing with
@@ -7606,8 +7609,8 @@ to_fixed_array_type (struct type *type0,
     {
       /* So far, the resulting type has been created as if the original
 	 type was a regular (non-packed) array type.  As a result, the
-	 bitsize of the array elements needs to be set again, and the array
-	 length needs to be recomputed based on that bitsize.  */
+	 bitsize of the array elements needs to be set again, and the
+	 array length needs to be recomputed based on that bitsize.  */
       int len = TYPE_LENGTH (result) / TYPE_LENGTH (TYPE_TARGET_TYPE (result));
       int elt_bitsize = TYPE_FIELD_BITSIZE (type0, 0);
 
@@ -7630,9 +7633,9 @@ to_fixed_array_type (struct type *type0,
    
    If CHECK_TAG is not null, in the case of tagged types, this function
    attempts to locate the object's tag and use it to compute the actual
-   type.  However, when ADDRESS is null, we cannot use it to determine the
-   location of the tag, and therefore compute the tagged type's actual type.
-   So we return the tagged type without consulting the tag.  */
+   type.  However, when ADDRESS is null, we cannot use it to determine
+   the location of the tag, and therefore compute the tagged type's
+   actual type. So we return the tagged type without consulting the tag.  */
    
 static struct type *
 ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
@@ -7649,12 +7652,12 @@ ada_to_fixed_type_1 (struct type *type, 
         struct type *fixed_record_type =
           to_fixed_record_type (type, valaddr, address, NULL);
 
-        /* If STATIC_TYPE is a tagged type and we know the object's address,
-           then we can determine its tag, and compute the object's actual
-           type from there.  Note that we have to use the fixed record
-           type (the parent part of the record may have dynamic fields
-           and the way the location of _tag is expressed may depend on
-           them).  */
+        /* If STATIC_TYPE is a tagged type and we know the object's
+           address, then we can determine its tag, and compute the
+           object's actual type from there.  Note that we have to use
+           the fixed record type (the parent part of the record may
+           have dynamic fields and the way the location of _tag is
+           expressed may depend on them).  */
 
         if (check_tag && address != 0 && ada_is_tagged_type (static_type, 0))
           {
@@ -7688,11 +7691,11 @@ ada_to_fixed_type_1 (struct type *type, 
                    observed this when the debugging info is STABS, and
                    apparently it is something that is hard to fix.
 
-                   In practice, we don't need the actual type definition
-                   at all, because the presence of the XVZ variable allows us
-                   to assume that there must be a XVS type as well, which we
-                   should be able to use later, when we need the actual type
-                   definition.
+                   In practice, we don't need the actual type
+                   definition at all, because the presence of the XVZ
+                   variable allows us to assume that there must be a
+                   XVS type as well, which we should be able to use
+                   later, when we need the actual type definition.
 
                    In the meantime, pretend that the "fixed" type we are
                    returning is NOT a stub, because this can cause trouble
@@ -7701,9 +7704,9 @@ ada_to_fixed_type_1 (struct type *type, 
                    whether the target type is a stub and will try to replace
                    it, thus using a type with the wrong size.  This, in turn,
                    might cause the new type to have the wrong size too.
-                   Consider the case of an array, for instance, where the size
-                   of the array is computed from the number of elements in
-                   our array multiplied by the size of its element.  */
+                   Consider the case of an array, for instance, where the
+                   size of the array is computed from the number of elements
+                   in our array multiplied by the size of its element.  */
                 TYPE_STUB (fixed_record_type) = 0;
               }
           }
@@ -7723,9 +7726,9 @@ ada_to_fixed_type_1 (struct type *type, 
    if it is a TYPE_CODE_TYPEDEF of a type that is already fixed.
 
    The typedef layer needs be preserved in order to differentiate between
-   arrays and array pointers when both types are implemented using the same
-   fat pointer.  In the array pointer case, the pointer is encoded as
-   a typedef of the pointer type.  For instance, considering:
+   arrays and array pointers when both types are implemented using the
+   same fat pointer.  In the array pointer case, the pointer is encoded
+   as a typedef of the pointer type.  For instance, considering:
 
 	  type String_Access is access String;
 	  S1 : String_Access := null;
@@ -7747,23 +7750,23 @@ ada_to_fixed_type (struct type *type, co
   struct type *fixed_type =
     ada_to_fixed_type_1 (type, valaddr, address, dval, check_tag);
 
-  /*  If TYPE is a typedef and its target type is the same as the FIXED_TYPE,
-      then preserve the typedef layer.
+  /*  If TYPE is a typedef and its target type is the same as the
+      FIXED_TYPE, then preserve the typedef layer.
 
       Implementation note: We can only check the main-type portion of
       the TYPE and FIXED_TYPE, because eliminating the typedef layer
       from TYPE now returns a type that has the same instance flags
       as TYPE.  For instance, if TYPE is a "typedef const", and its
-      target type is a "struct", then the typedef elimination will return
-      a "const" version of the target type.  See check_typedef for more
-      details about how the typedef layer elimination is done.
-
-      brobecker/2010-11-19: It seems to me that the only case where it is
-      useful to preserve the typedef layer is when dealing with fat pointers.
-      Perhaps, we could add a check for that and preserve the typedef layer
-      only in that situation.  But this seems unecessary so far, probably
-      because we call check_typedef/ada_check_typedef pretty much everywhere.
-      */
+      target type is a "struct", then the typedef elimination will
+      return a "const" version of the target type.  See check_typedef
+      for more details about how the typedef layer elimination is done.
+
+      brobecker/2010-11-19: It seems to me that the only case where it
+      is useful to preserve the typedef layer is when dealing with fat
+      pointers.  Perhaps, we could add a check for that and preserve
+      the typedef layer only in that situation.  But this seems
+      unecessary so far, probably because we call
+      check_typedef/ada_check_typedef pretty much everywhere.  */
   if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF
       && (TYPE_MAIN_TYPE (ada_typedef_target_type (type))
 	  == TYPE_MAIN_TYPE (fixed_type)))
@@ -7873,10 +7876,10 @@ ada_check_typedef (struct type *type)
       if (type1 == NULL)
         return type;
 
-      /* TYPE1 might itself be a TYPE_CODE_TYPEDEF (this can happen with
-	 stubs pointing to arrays, as we don't create symbols for array
-	 types, only for the typedef-to-array types).  If that's the case,
-	 strip the typedef layer.  */
+      /* TYPE1 might itself be a TYPE_CODE_TYPEDEF (this can happen
+	 with stubs pointing to arrays, as we don't create symbols for
+	 array types, only for the typedef-to-array types).  If that's
+	 the case, strip the typedef layer.  */
       if (TYPE_CODE (type1) == TYPE_CODE_TYPEDEF)
 	type1 = ada_check_typedef (type1);
 
@@ -7917,8 +7920,8 @@ ada_to_fixed_value (struct value *val)
 
 /* Attributes */
 
-/* Table mapping attribute numbers to names.
-   NOTE: Keep up to date with enum ada_attribute definition in ada-lang.h.  */
+/* Table mapping attribute numbers to names.  NOTE: Keep up to date
+   with enum ada_attribute definition in ada-lang.h.  */
 
 static const char *attribute_names[] = {
   "<?>",
@@ -8061,8 +8064,8 @@ ada_is_string_type (struct type *type)
    Otherwise, ignore the PAD type if there is a parallel XVS type.  */
 static int trust_pad_over_xvs = 1;
 
-/* True if TYPE is a struct type introduced by the compiler to force the
-   alignment of a value.  Such types have a single field with a
+/* True if TYPE is a struct type introduced by the compiler to force
+   the alignment of a value.  Such types have a single field with a
    distinctive name.  */
 
 int
@@ -8113,9 +8116,9 @@ ada_get_base_type (struct type *raw_type
 
   if (TYPE_CODE (TYPE_FIELD_TYPE (real_type_namer, 0)) != TYPE_CODE_REF)
     {
-      /* This is an older encoding form where the base type needs to be
-	 looked up by name.  We prefer the newer enconding because it is
-	 more efficient.  */
+      /* This is an older encoding form where the base type needs to
+	 be looked up by name.  We prefer the newer enconding because
+	 it is more efficient.  */
       raw_real_type = ada_find_any_type (TYPE_FIELD_NAME (real_type_namer, 0));
       if (raw_real_type == NULL)
 	return raw_type;
@@ -8457,8 +8460,8 @@ num_component_specs (struct expression *
    LHS == CONTAINER).  */
 
 static void
-assign_component (struct value *container, struct value *lhs, LONGEST index,
-		  struct expression *exp, int *pos)
+assign_component (struct value *container, struct value *lhs,
+		  LONGEST index, struct expression *exp, int *pos)
 {
   struct value *mark = value_mark ();
   struct value *elt;
@@ -8585,9 +8588,9 @@ assign_aggregate (struct value *containe
    updating *NUM_INDICES as needed.  CONTAINER is as for
    assign_aggregate.  */
 static void
-aggregate_assign_positional (struct value *container,
-			     struct value *lhs, struct expression *exp,
-			     int *pos, LONGEST *indices, int *num_indices,
+aggregate_assign_positional (struct value *container, struct value *lhs,
+			     struct expression *exp, int *pos,
+			     LONGEST *indices, int *num_indices,
 			     int max_indices, LONGEST low, LONGEST high) 
 {
   LONGEST ind = longest_to_int (exp->elts[*pos + 1].longconst) + low;
@@ -8610,9 +8613,9 @@ aggregate_assign_positional (struct valu
    to in INDICES[0 .. MAX_INDICES-1], updating *NUM_INDICES as
    needed.  CONTAINER is as for assign_aggregate.  */
 static void
-aggregate_assign_from_choices (struct value *container,
-			       struct value *lhs, struct expression *exp,
-			       int *pos, LONGEST *indices, int *num_indices,
+aggregate_assign_from_choices (struct value *container, struct value *lhs,
+			       struct expression *exp, int *pos,
+			       LONGEST *indices, int *num_indices,
 			       int max_indices, LONGEST low, LONGEST high) 
 {
   int j;
@@ -8687,10 +8690,10 @@ aggregate_assign_from_choices (struct va
 }
 
 /* Assign the value of the expression in the OP_OTHERS construct in
-   EXP at *POS into the components of LHS indexed from LOW .. HIGH that
-   have not been previously assigned.  The index intervals already assigned
-   are in INDICES[0 .. NUM_INDICES-1].  Updates *POS to after the 
-   OP_OTHERS clause.  CONTAINER is as for assign_aggregate.  */
+   EXP at *POS into the components of LHS indexed from LOW .. HIGH
+   that have not been previously assigned.  The index intervals
+   already assigned are in INDICES[0 .. NUM_INDICES-1].  Updates *POS
+   to after the OP_OTHERS clause.  CONTAINER is as for assign_aggregate.  */
 static void
 aggregate_assign_others (struct value *container,
 			 struct value *lhs, struct expression *exp,
@@ -8781,11 +8784,11 @@ ada_value_cast (struct type *type, struc
 
     We usually evaluate an Ada expression in order to print its value.
     We also evaluate an expression in order to print its type, which
-    happens during the EVAL_AVOID_SIDE_EFFECTS phase of the evaluation,
-    but we'll focus mostly on the EVAL_NORMAL phase.  In practice, the
-    EVAL_AVOID_SIDE_EFFECTS phase allows us to simplify certain aspects of
-    the evaluation compared to the EVAL_NORMAL, but is otherwise very
-    similar.
+    happens during the EVAL_AVOID_SIDE_EFFECTS phase of the
+    evaluation, but we'll focus mostly on the EVAL_NORMAL phase.  In
+    practice, the EVAL_AVOID_SIDE_EFFECTS phase allows us to simplify
+    certain aspects of the evaluation compared to the EVAL_NORMAL, but
+    is otherwise very similar.
 
     Evaluating expressions is a little more complicated for Ada entities
     than it is for entities in languages such as C.  The main reason for
@@ -8794,18 +8797,18 @@ ada_value_cast (struct type *type, struc
     would be an array whose bounds can only be known at run time.
 
     The following description is a general guide as to what should be
-    done (and what should NOT be done) in order to evaluate an expression
-    involving such types, and when.  This does not cover how the semantic
-    information is encoded by GNAT as this is covered separatly.  For the
-    document used as the reference for the GNAT encoding, see exp_dbug.ads
-    in the GNAT sources.
+    done (and what should NOT be done) in order to evaluate an
+    expression involving such types, and when.  This does not cover
+    how the semantic information is encoded by GNAT as this is covered
+    separatly.  For the document used as the reference for the GNAT
+    encoding, see exp_dbug.ads in the GNAT sources.
 
     Ideally, we should embed each part of this description next to its
-    associated code.  Unfortunately, the amount of code is so vast right
-    now that it's hard to see whether the code handling a particular
-    situation might be duplicated or not.  One day, when the code is
-    cleaned up, this guide might become redundant with the comments
-    inserted in the code, and we might want to remove it.
+    associated code.  Unfortunately, the amount of code is so vast
+    right now that it's hard to see whether the code handling a
+    particular situation might be duplicated or not.  One day, when
+    the code is cleaned up, this guide might become redundant with the
+    comments inserted in the code, and we might want to remove it.
 
     2. ``Fixing'' an Entity, the Simple Case:
     -----------------------------------------
@@ -8831,8 +8834,8 @@ ada_value_cast (struct type *type, struc
     We also informally refer to this opperation as "fixing" an object,
     which means creating its associated fixed type.
 
-    Example: when printing the value of variable "Yes" above, its fixed
-    type would look like this:
+    Example: when printing the value of variable "Yes" above, its
+    fixed type would look like this:
 
        type Rec is record
           Empty : Boolean;
@@ -8846,24 +8849,24 @@ ada_value_cast (struct type *type, struc
           Empty : Boolean;
        end record;
 
-    Things become a little more complicated when trying to fix an entity
-    with a dynamic type that directly contains another dynamic type,
-    such as an array of variant records, for instance.  There are
-    two possible cases: Arrays, and records.
+    Things become a little more complicated when trying to fix an
+    entity with a dynamic type that directly contains another dynamic
+    type, such as an array of variant records, for instance.  There
+    are two possible cases: Arrays, and records.
 
     3. ``Fixing'' Arrays:
     ---------------------
 
-    The type structure in GDB describes an array in terms of its bounds,
-    and the type of its elements.  By design, all elements in the array
-    have the same type and we cannot represent an array of variant elements
-    using the current type structure in GDB.  When fixing an array,
-    we cannot fix the array element, as we would potentially need one
-    fixed type per element of the array.  As a result, the best we can do
-    when fixing an array is to produce an array whose bounds and size
-    are correct (allowing us to read it from memory), but without having
-    touched its element type.  Fixing each element will be done later,
-    when (if) necessary.
+    The type structure in GDB describes an array in terms of its
+    bounds, and the type of its elements.  By design, all elements in
+    the array have the same type and we cannot represent an array of
+    variant elements using the current type structure in GDB.  When
+    fixing an array, we cannot fix the array element, as we would
+    potentially need one fixed type per element of the array.  As a
+    result, the best we can do when fixing an array is to produce an
+    array whose bounds and size are correct (allowing us to read it
+    from memory), but without having touched its element type.  Fixing
+    each element will be done later, when (if) necessary.
 
     Arrays are a little simpler to handle than records, because the same
     amount of memory is allocated for each element of the array, even if
@@ -8872,13 +8875,13 @@ ada_value_cast (struct type *type, struc
 
        type Rec_Array is array (1 .. 2) of Rec;
 
-    The actual amount of memory occupied by each element might be different
-    from element to element, depending on the value of their discriminant.
-    But the amount of space reserved for each element in the array remains
-    fixed regardless.  So we simply need to compute that size using
-    the debugging information available, from which we can then determine
-    the array size (we multiply the number of elements of the array by
-    the size of each element).
+    The actual amount of memory occupied by each element might be
+    different from element to element, depending on the value of their
+    discriminant.  But the amount of space reserved for each element
+    in the array remains fixed regardless.  So we simply need to
+    compute that size using the debugging information available, from
+    which we can then determine the array size (we multiply the number
+    of elements of the array by the size of each element).
 
     The simplest case is when we have an array of a constrained element
     type. For instance, consider the following type declarations:
@@ -8893,11 +8896,11 @@ ada_value_cast (struct type *type, struc
     variable-size elements (identified by its XVS suffix) for which
     the size can be read in the parallel XVZ variable.
 
-    In the case of an array of an unconstrained element type, the compiler
-    wraps the array element inside a private PAD type.  This type should not
-    be shown to the user, and must be "unwrap"'ed before printing.  Note
-    that we also use the adjective "aligner" in our code to designate
-    these wrapper types.
+    In the case of an array of an unconstrained element type, the
+    compiler wraps the array element inside a private PAD type.  This
+    type should not be shown to the user, and must be "unwrap"'ed
+    before printing.  Note that we also use the adjective "aligner" in
+    our code to designate these wrapper types.
 
     In some cases, the size allocated for each element is statically
     known.  In that case, the PAD type already has the correct size,
@@ -8950,10 +8953,10 @@ ada_value_cast (struct type *type, struc
     we need to fix the type of field Str.  Therefore, fixing a variant
     record requires us to fix each of its components.
 
-    However, if a component does not have a dynamic size, the component
-    should not be fixed.  In particular, fields that use a PAD type
-    should not fixed.  Here is an example where this might happen
-    (assuming type Rec above):
+    However, if a component does not have a dynamic size, the
+    component should not be fixed.  In particular, fields that use a
+    PAD type should not fixed.  Here is an example where this might
+    happen (assuming type Rec above):
 
        type Container (Big : Boolean) is record
           First : Rec;
@@ -8967,20 +8970,21 @@ ada_value_cast (struct type *type, struc
                                     First => (Empty => True),
                                     After => 42);
 
-    In that example, the compiler creates a PAD type for component First,
-    whose size is constant, and then positions the component After just
-    right after it.  The offset of component After is therefore constant
-    in this case.
-
-    The debugger computes the position of each field based on an algorithm
-    that uses, among other things, the actual position and size of the field
-    preceding it.  Let's now imagine that the user is trying to print
-    the value of My_Container.  If the type fixing was recursive, we would
-    end up computing the offset of field After based on the size of the
-    fixed version of field First.  And since in our example First has
-    only one actual field, the size of the fixed type is actually smaller
-    than the amount of space allocated to that field, and thus we would
-    compute the wrong offset of field After.
+    In that example, the compiler creates a PAD type for component
+    First, whose size is constant, and then positions the component
+    After just right after it.  The offset of component After is
+    therefore constant in this case.
+
+    The debugger computes the position of each field based on an
+    algorithm that uses, among other things, the actual position and
+    size of the field preceding it.  Let's now imagine that the user
+    is trying to print the value of My_Container.  If the type fixing
+    was recursive, we would end up computing the offset of field After
+    based on the size of the fixed version of field First.  And since
+    in our example First has only one actual field, the size of the
+    fixed type is actually smaller than the amount of space allocated
+    to that field, and thus we would compute the wrong offset of field
+    After.
 
     To make things more complicated, we need to watch out for dynamic
     components of variant records (identified by the ___XVL suffix in
@@ -9005,8 +9009,8 @@ ada_value_cast (struct type *type, struc
     4. When to ``Fix'' un-``Fixed'' sub-elements of an entity:
     ----------------------------------------------------------
 
-    Lastly, when should the sub-elements of an entity that remained unfixed
-    thus far, be actually fixed?
+    Lastly, when should the sub-elements of an entity that remained
+    unfixed thus far, be actually fixed?
 
     The answer is: Only when referencing that element.  For instance
     when selecting one component of a record, this specific component
@@ -9018,14 +9022,14 @@ ada_value_cast (struct type *type, struc
     not be performed on the elements when taking a slice of an array!
 
     Note that one of the side-effects of miscomputing the offset and
-    size of each field is that we end up also miscomputing the size
-    of the containing type.  This can have adverse results when computing
+    size of each field is that we end up also miscomputing the size of
+    the containing type.  This can have adverse results when computing
     the value of an entity.  GDB fetches the value of an entity based
     on the size of its type, and thus a wrong size causes GDB to fetch
-    the wrong amount of memory.  In the case where the computed size is
-    too small, GDB fetches too little data to print the value of our
-    entiry.  Results in this case as unpredicatble, as we usually read
-    past the buffer containing the data =:-o.  */
+    the wrong amount of memory.  In the case where the computed size
+    is too small, GDB fetches too little data to print the value of
+    our entiry.  Results in this case as unpredicatble, as we usually
+    read past the buffer containing the data =:-o.  */
 
 /* Implement the evaluate_exp routine in the exp_descriptor structure
    for the Ada language.  */
@@ -9115,8 +9119,8 @@ ada_evaluate_subexp (struct type *expect
       if (ada_is_fixed_point_type (value_type (arg1)))
         arg2 = cast_to_fixed (value_type (arg1), arg2);
       else if (ada_is_fixed_point_type (value_type (arg2)))
-        error
-          (_("Fixed-point values must be assigned to fixed-point variables"));
+        error (_("Fixed-point values must be "
+		 "assigned to fixed-point variables"));
       else
         arg2 = coerce_for_assign (value_type (arg1), arg2);
       return ada_value_assign (arg1, arg2);
@@ -9157,9 +9161,9 @@ ada_evaluate_subexp (struct type *expect
           && value_type (arg1) != value_type (arg2))
         error (_("Operands of fixed-point subtraction "
 		 "must have the same type"));
-      /* Do the substraction, and cast the result to the type of the first
-         argument.  We cannot cast the result to a reference type, so if
-         ARG1 is a reference type, find its underlying type.  */
+      /* Do the substraction, and cast the result to the type of the
+         first argument.  We cannot cast the result to a reference
+         type, so if ARG1 is a reference type, find its underlying type.  */
       type = value_type (arg1);
       while (TYPE_CODE (type) == TYPE_CODE_REF)
         type = TYPE_TARGET_TYPE (type);
@@ -9271,23 +9275,24 @@ ada_evaluate_subexp (struct type *expect
               || (TYPE_CODE(type) == TYPE_CODE_REF
                   && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0)))
           {
-            /* Tagged types are a little special in the fact that the real
-               type is dynamic and can only be determined by inspecting the
-               object's tag.  This means that we need to get the object's
-               value first (EVAL_NORMAL) and then extract the actual object
-               type from its tag.
-
-               Note that we cannot skip the final step where we extract
-               the object type from its tag, because the EVAL_NORMAL phase
-               results in dynamic components being resolved into fixed ones.
-               This can cause problems when trying to print the type
-               description of tagged types whose parent has a dynamic size:
-               We use the type name of the "_parent" component in order
-               to print the name of the ancestor type in the type description.
-               If that component had a dynamic size, the resolution into
-               a fixed type would result in the loss of that type name,
-               thus preventing us from printing the name of the ancestor
-               type in the type description.  */
+            /* Tagged types are a little special in the fact that the
+               real type is dynamic and can only be determined by
+               inspecting the object's tag.  This means that we need
+               to get the object's value first (EVAL_NORMAL) and then
+               extract the actual object type from its tag.
+
+               Note that we cannot skip the final step where we
+               extract the object type from its tag, because the
+               EVAL_NORMAL phase results in dynamic components being
+               resolved into fixed ones.  This can cause problems when
+               trying to print the type description of tagged types
+               whose parent has a dynamic size: We use the type name
+               of the "_parent" component in order to print the name
+               of the ancestor type in the type description.  If that
+               component had a dynamic size, the resolution into a
+               fixed type would result in the loss of that type name,
+               thus preventing us from printing the name of the
+               ancestor type in the type description.  */
             struct type *actual_type;
 
             arg1 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
@@ -9355,9 +9360,9 @@ ada_evaluate_subexp (struct type *expect
 
       type = ada_check_typedef (value_type (argvec[0]));
 
-      /* Ada allows us to implicitly dereference arrays when subscripting
-         them.  So, if this is an typedef (encoding use for array access
-	 types encoded as fat pointers), strip it now.  */
+      /* Ada allows us to implicitly dereference arrays when
+         subscripting them.  So, if this is an typedef (encoding use
+         for array access types encoded as fat pointers), strip it now.  */
       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 	type = ada_typedef_target_type (type);
 
@@ -9485,10 +9490,10 @@ ada_evaluate_subexp (struct type *expect
                      == TYPE_CODE_PTR))
           array = value_ind (array);
 
-        /* Make sure we really do have an array type before going further,
-           to avoid a SEGV when trying to get the index type or the target
-           type later down the road if the debug info generated by
-           the compiler is incorrect or incomplete.  */
+        /* Make sure we really do have an array type before going
+           further, to avoid a SEGV when trying to get the index type
+           or the target type later down the road if the debug info
+           generated by the compiler is incorrect or incomplete.  */
         if (!ada_is_simple_array_type (value_type (array)))
           error (_("cannot take slice of non-array"));
 
@@ -10046,9 +10051,9 @@ scaling_factor (struct type *type)
   DOUBLEST num0, den0, num1, den1;
   int n;
 
-  /* Strictly speaking, num's and den's are encoded as integer.  However,
-     they may not fit into a long, and they will have to be converted
-     to DOUBLEST anyway.  So scan them as DOUBLEST.  */
+  /* Strictly speaking, num's and den's are encoded as integer.
+     However, they may not fit into a long, and they will have to be
+     converted to DOUBLEST anyway.  So scan them as DOUBLEST.  */
   n = sscanf (encoding,
 	      "_%" DOUBLEST_SCAN_FORMAT "_%" DOUBLEST_SCAN_FORMAT
 	      "_%" DOUBLEST_SCAN_FORMAT "_%" DOUBLEST_SCAN_FORMAT,
@@ -10139,8 +10144,8 @@ get_var_value (char *name, char *err_msg
   struct ada_symbol_info *syms;
   int nsyms;
 
-  nsyms = ada_lookup_symbol_list (name, get_selected_block (0), VAR_DOMAIN,
-                                  &syms);
+  nsyms = ada_lookup_symbol_list (name, get_selected_block (0),
+                                  VAR_DOMAIN, &syms);
 
   if (nsyms != 1)
     {
@@ -10153,8 +10158,8 @@ get_var_value (char *name, char *err_msg
   return value_of_variable (syms[0].sym, syms[0].block);
 }
 
-/* Value of integer variable named NAME in the current environment.  If
-   no such variable found, returns 0, and sets *FLAG to 0.  If
+/* Value of integer variable named NAME in the current environment.
+   If no such variable found, returns 0, and sets *FLAG to 0.  If
    successful, sets *FLAG to 1.  */
 
 LONGEST
@@ -10181,10 +10186,10 @@ get_int_var_value (char *name, int *flag
    NAME in the current environment, and whose bounds are calculated
    from NAME according to the GNAT range encoding conventions.
    Extract discriminant values, if needed, from DVAL.  ORIG_TYPE is the
-   corresponding range type from debug information; fall back to using it
-   if symbol lookup fails.  If a new type must be created, allocate it
-   like ORIG_TYPE was.  The bounds information, in general, is encoded
-   in NAME, the base type given in the named range type.  */
+   corresponding range type from debug information; fall back to using
+   it if symbol lookup fails.  If a new type must be created, allocate
+   it like ORIG_TYPE was.  The bounds information, in general, is
+   encoded in NAME, the base type given in the named range type.  */
 
 static struct type *
 to_fixed_range_type (struct type *raw_type, struct value *dval)
@@ -10305,9 +10310,9 @@ ada_is_modular_type (struct type *type)
           && TYPE_UNSIGNED (subranged_type));
 }
 
-/* Try to determine the lower and upper bounds of the given modular type
-   using the type name only.  Return non-zero and set L and U as the lower
-   and upper bounds (respectively) if successful.  */
+/* Try to determine the lower and upper bounds of the given modular
+   type using the type name only.  Return non-zero and set L and U as
+   the lower and upper bounds (respectively) if successful.  */
 
 int
 ada_modulus_from_name (struct type *type, ULONGEST *modulus)
@@ -10320,11 +10325,11 @@ ada_modulus_from_name (struct type *type
   if (name == NULL)
     return 0;
 
-  /* Discrete type bounds are encoded using an __XD suffix.  In our case,
-     we are looking for static bounds, which means an __XDLU suffix.
-     Moreover, we know that the lower bound of modular types is always
-     zero, so the actual suffix should start with "__XDLU_0__", and
-     then be followed by the upper bound value.  */
+  /* Discrete type bounds are encoded using an __XD suffix.  In our
+     case, we are looking for static bounds, which means an __XDLU
+     suffix.  Moreover, we know that the lower bound of modular types
+     is always zero, so the actual suffix should start with
+     "__XDLU_0__", and then be followed by the upper bound value.  */
   suffix = strstr (name, "__XDLU_0__");
   if (suffix == NULL)
     return 0;
@@ -10354,16 +10359,16 @@ ada_modulus (struct type *type)
      . catchpoints on failed assertions
 
    Exceptions raised during failed assertions, or unhandled exceptions
-   could perfectly be caught with the general catchpoint on Ada exceptions.
-   However, we can easily differentiate these two special cases, and having
-   the option to distinguish these two cases from the rest can be useful
-   to zero-in on certain situations.
+   could perfectly be caught with the general catchpoint on Ada
+   exceptions.  However, we can easily differentiate these two special
+   cases, and having the option to distinguish these two cases from
+   the rest can be useful to zero-in on certain situations.
 
    Exception catchpoints are a specialized form of breakpoint,
    since they rely on inserting breakpoints inside known routines
    of the GNAT runtime.  The implementation therefore uses a standard
-   breakpoint structure of the BP_BREAKPOINT type, but with its own set
-   of breakpoint_ops.
+   breakpoint structure of the BP_BREAKPOINT type, but with its own
+   set of breakpoint_ops.
 
    Support in the runtime for exception catchpoints have been changed
    a few times already, and these changes affect the implementation
@@ -10371,17 +10376,17 @@ ada_modulus (struct type *type)
    variants of the runtime, we use a sniffer that will determine
    the runtime variant used by the program being debugged.
 
-   At this time, we do not support the use of conditions on Ada exception
-   catchpoints.  The COND and COND_STRING fields are therefore set
-   to NULL (most of the time, see below).
+   At this time, we do not support the use of conditions on Ada
+   exception catchpoints.  The COND and COND_STRING fields are
+   therefore set to NULL (most of the time, see below).
    
    Conditions where EXP_STRING, COND, and COND_STRING are used:
 
-     When a user specifies the name of a specific exception in the case
-     of catchpoints on Ada exceptions, we store the name of that exception
-     in the EXP_STRING.  We then translate this request into an actual
-     condition stored in COND_STRING, and then parse it into an expression
-     stored in COND.  */
+     When a user specifies the name of a specific exception in the
+     case of catchpoints on Ada exceptions, we store the name of that
+     exception in the EXP_STRING.  We then translate this request into
+     an actual condition stored in COND_STRING, and then parse it into
+     an expression stored in COND.  */
 
 /* The different types of catchpoints that we introduced for catching
    Ada exceptions.  */
@@ -10422,9 +10427,9 @@ struct exception_support_info
    const char *catch_assert_sym;
 
    /* Assuming that the inferior just triggered an unhandled exception
-      catchpoint, this function is responsible for returning the address
-      in inferior memory where the name of that exception is stored.
-      Return zero if the address could not be computed.  */
+      catchpoint, this function is responsible for returning the
+      address in inferior memory where the name of that exception is
+      stored.  Return zero if the address could not be computed.  */
    ada_unhandled_exception_name_addr_ftype *unhandled_exception_name_addr;
 };
 
@@ -10494,9 +10499,9 @@ ada_exception_support_info_sniffer (void
 
   /* Sometimes, it is normal for us to not be able to find the routine
      we are looking for.  This happens when the program is linked with
-     the shared version of the GNAT runtime, and the program has not been
-     started yet.  Inform the user of these two possible causes if
-     applicable.  */
+     the shared version of the GNAT runtime, and the program has not
+     been started yet.  Inform the user of these two possible causes
+     if applicable.  */
 
   if (ada_update_initial_language (language_unknown) != language_ada)
     error (_("Unable to insert catchpoint.  Is this an Ada main program?"));
@@ -10520,22 +10525,22 @@ ada_exception_support_info_sniffer (void
 }
 
 /* An observer of "executable_changed" events.
-   Its role is to clear certain cached values that need to be recomputed
-   each time a new executable is loaded by GDB.  */
+   Its role is to clear certain cached values that need to be
+   recomputed each time a new executable is loaded by GDB.  */
 
 static void
 ada_executable_changed_observer (void)
 {
-  /* If the executable changed, then it is possible that the Ada runtime
-     is different.  So we need to invalidate the exception support info
-     cache.  */
+  /* If the executable changed, then it is possible that the Ada
+     runtime is different.  So we need to invalidate the exception
+     support info cache.  */
   exception_info = NULL;
 }
 
-/* True iff FRAME is very likely to be that of a function that is
-   part of the runtime system.  This is all very heuristic, but is
-   intended to be used as advice as to what frames are uninteresting
-   to most users.  */
+/* True iff FRAME is very likely to be that of a function that is part
+   of the runtime system.  This is all very heuristic, but is intended
+   to be used as advice as to what frames are uninteresting to most
+   users.  */
 
 static int
 is_known_support_routine (struct frame_info *frame)
@@ -10592,8 +10597,8 @@ is_known_support_routine (struct frame_i
   return 0;
 }
 
-/* Find the first frame that contains debugging information and that is not
-   part of the Ada run-time, starting from FI and moving upward.  */
+/* Find the first frame that contains debugging information and that is
+   not part of the Ada run-time, starting from FI and moving upward.  */
 
 void
 ada_find_printable_frame (struct frame_info *fi)
@@ -10621,10 +10626,10 @@ ada_unhandled_exception_name_addr (void)
   return parse_and_eval_address ("e.full_name");
 }
 
-/* Same as ada_unhandled_exception_name_addr, except that this function
-   should be used when the inferior uses an older version of the runtime,
-   where the exception name needs to be extracted from a specific frame
-   several frames up in the callstack.  */
+/* Same as ada_unhandled_exception_name_addr, except that this
+   function should be used when the inferior uses an older version of
+   the runtime, where the exception name needs to be extracted from a
+   specific frame several frames up in the callstack.  */
 
 static CORE_ADDR
 ada_unhandled_exception_name_addr_from_raise (void)
@@ -10692,10 +10697,10 @@ ada_exception_name_addr_1 (enum exceptio
   return 0; /* Should never be reached.  */
 }
 
-/* Same as ada_exception_name_addr_1, except that it intercepts and contains
-   any error that ada_exception_name_addr_1 might cause to be thrown.
-   When an error is intercepted, a warning with the error message is printed,
-   and zero is returned.  */
+/* Same as ada_exception_name_addr_1, except that it intercepts and
+   contains any error that ada_exception_name_addr_1 might cause to be
+   thrown.  When an error is intercepted, a warning with the error
+   message is printed, and zero is returned.  */
 
 static CORE_ADDR
 ada_exception_name_addr (enum exception_catchpoint_kind ex,
@@ -11129,10 +11134,10 @@ ada_exception_breakpoint_ops (enum excep
     }
 }
 
-/* Return the condition that will be used to match the current exception
-   being raised with the exception that the user wants to catch.  This
-   assumes that this condition is used when the inferior just triggered
-   an exception catchpoint.
+/* Return the condition that will be used to match the current
+   exception being raised with the exception that the user wants to
+   catch.  This assumes that this condition is used when the inferior
+   just triggered an exception catchpoint.
    
    The string returned is a newly allocated string that needs to be
    deallocated later.  */
@@ -11156,10 +11161,10 @@ ada_exception_catchpoint_cond_string (co
      exception constraint_error" is rewritten into "catch exception
      standard.constraint_error".
 
-     If an exception named contraint_error is defined in another package of
-     the inferior program, then the only way to specify this exception as a
-     breakpoint condition is to use its fully-qualified named:
-     e.g. my_package.constraint_error.  */
+     If an exception named contraint_error is defined in another
+     package of the inferior program, then the only way to specify
+     this exception as a breakpoint condition is to use its
+     fully-qualified named: e.g. my_package.constraint_error.  */
 
   for (i = 0; i < sizeof (standard_exc) / sizeof (char *); i++)
     {
@@ -11181,17 +11186,17 @@ ada_parse_catchpoint_condition (char *co
   return (parse_exp_1 (&cond_string, block_for_pc (sal.pc), 0));
 }
 
-/* Return the symtab_and_line that should be used to insert an exception
-   catchpoint of the TYPE kind.
+/* Return the symtab_and_line that should be used to insert an
+   exception catchpoint of the TYPE kind.
 
    EX_STRING should contain the name of a specific exception
    that the catchpoint should catch, or NULL otherwise.
 
-   The idea behind all the remaining parameters is that their names match
-   the name of certain fields in the breakpoint structure that are used to
-   handle exception catchpoints.  This function returns the value to which
-   these fields should be set, depending on the type of catchpoint we need
-   to create.
+   The idea behind all the remaining parameters is that their names
+   match the name of certain fields in the breakpoint structure that
+   are used to handle exception catchpoints.  This function returns
+   the value to which these fields should be set, depending on the
+   type of catchpoint we need to create.
    
    If COND and COND_STRING are both non-NULL, any value they might
    hold will be free'ed, and then replaced by newly allocated ones.
@@ -11215,22 +11220,23 @@ ada_exception_sal (enum exception_catchp
   sym_name = ada_exception_sym_name (ex);
   sym = standard_lookup (sym_name, NULL, VAR_DOMAIN);
 
-  /* The symbol we're looking up is provided by a unit in the GNAT runtime
-     that should be compiled with debugging information.  As a result, we
-     expect to find that symbol in the symtabs.  If we don't find it, then
-     the target most likely does not support Ada exceptions, or we cannot
-     insert exception breakpoints yet, because the GNAT runtime hasn't been
-     loaded yet.  */
-
-  /* brobecker/2006-12-26: It is conceivable that the runtime was compiled
-     in such a way that no debugging information is produced for the symbol
-     we are looking for.  In this case, we could search the minimal symbols
-     as a fall-back mechanism.  This would still be operating in degraded
-     mode, however, as we would still be missing the debugging information
-     that is needed in order to extract the name of the exception being
-     raised (this name is printed in the catchpoint message, and is also
-     used when trying to catch a specific exception).  We do not handle
-     this case for now.  */
+  /* The symbol we're looking up is provided by a unit in the GNAT
+     runtime that should be compiled with debugging information.  As a
+     result, we expect to find that symbol in the symtabs.  If we
+     don't find it, then the target most likely does not support Ada
+     exceptions, or we cannot insert exception breakpoints yet,
+     because the GNAT runtime hasn't been loaded yet.  */
+
+  /* brobecker/2006-12-26: It is conceivable that the runtime was
+     compiled in such a way that no debugging information is produced
+     for the symbol we are looking for.  In this case, we could search
+     the minimal symbols as a fall-back mechanism.  This would still
+     be operating in degraded mode, however, as we would still be
+     missing the debugging information that is needed in order to
+     extract the name of the exception being raised (this name is
+     printed in the catchpoint message, and is also used when trying
+     to catch a specific exception).  We do not handle this case for
+     now.  */
 
   if (sym == NULL)
     error (_("Unable to break on '%s' in this configuration."), sym_name);
@@ -11340,8 +11346,8 @@ ada_decode_assert_location (char *args, 
     OP_DEFN (OP_DISCRETE_RANGE, 1, 2, 0)
 
 static void
-ada_operator_length (const struct expression *exp, int pc, int *oplenp,
-		     int *argsp)
+ada_operator_length (const struct expression *exp, int pc,
+		     int *oplenp, int *argsp)
 {
   switch (exp->elts[pc - 1].opcode)
     {
Index: ada-lang.h
===================================================================
RCS file: /cvs/src/src/gdb/ada-lang.h,v
retrieving revision 1.63
diff -u -p -u -p -r1.63 ada-lang.h
--- ada-lang.h	7 Jan 2011 19:36:14 -0000	1.63
+++ ada-lang.h	12 Jan 2011 03:12:28 -0000
@@ -66,8 +66,8 @@ struct frame_info;
 
 struct block;
 
-/* Corresponding encoded/decoded names and opcodes for Ada user-definable
-   operators.  */
+/* Corresponding encoded/decoded names and opcodes for Ada
+   user-definable operators.  */
 struct ada_opname_map
 {
   const char *encoded;
@@ -135,13 +135,13 @@ struct ada_task_info
      the ID of the other task.  Zero otherwise.  */
   CORE_ADDR called_task;
 
-  /* If the task is accepting a rendezvous with another task, this field
-     contains the ID of the calling task.  Zero otherwise.  */
+  /* If the task is accepting a rendezvous with another task, this
+     field contains the ID of the calling task.  Zero otherwise.  */
   CORE_ADDR caller_task;
 };
 
-/* Assuming V points to an array of S objects,  make sure that it contains at
-   least M objects, updating V and S as necessary.  */
+/* Assuming V points to an array of S objects,  make sure that it
+   contains at least M objects, updating V and S as necessary.  */
 
 #define GROW_VECT(v, s, m)                                    \
    if ((s) < (m)) (v) = grow_vect (v, &(s), m, sizeof *(v));
@@ -157,14 +157,14 @@ extern int ada_parse (void);    /* Defin
 extern void ada_error (char *); /* Defined in ada-exp.y */
 
                         /* Defined in ada-typeprint.c */
-extern void ada_print_type (struct type *, const char *, struct ui_file *, int,
-                            int);
+extern void ada_print_type (struct type *, const char *,
+                            struct ui_file *, int, int);
 
 extern void ada_print_typedef (struct type *type, struct symbol *new_symbol,
 			       struct ui_file *stream);
 
-extern int ada_val_print (struct type *, const gdb_byte *, int, CORE_ADDR,
-                          struct ui_file *, int,
+extern int ada_val_print (struct type *, const gdb_byte *, int,
+                          CORE_ADDR, struct ui_file *, int,
 			  const struct value *,
 			  const struct value_print_options *);
 
@@ -364,8 +364,8 @@ extern void ada_print_scalar (struct typ
 extern int ada_is_range_type_name (const char *);
 
 extern enum ada_renaming_category ada_parse_renaming (struct symbol *,
-						      const char **,
-						      int *, const char **);
+						      const char **, int *,
+						      const char **);
 
 extern void ada_find_printable_frame (struct frame_info *fi);
 
Index: ada-lex.l
===================================================================
RCS file: /cvs/src/src/gdb/ada-lex.l,v
retrieving revision 1.30
diff -u -p -u -p -r1.30 ada-lex.l
--- ada-lex.l	1 Jan 2011 15:32:56 -0000	1.30
+++ ada-lex.l	12 Jan 2011 03:12:28 -0000
@@ -191,10 +191,10 @@ xor		{ return XOR; }
 
 	/* BOOLEAN "KEYWORDS" */
 
- /* True and False are not keywords in Ada, but rather enumeration constants.
-    However, the boolean type is no longer represented as an enum, so True
-    and False are no longer defined in symbol tables.  We compromise by
-    making them keywords (when bare). */
+ /* True and False are not keywords in Ada, but rather enumeration
+    constants.  However, the boolean type is no longer represented as
+    an enum, so True and False are no longer defined in symbol tables.
+    We compromise by making them keywords (when bare). */
 
 true		{ return TRUEKEYWORD; }
 false		{ return FALSEKEYWORD; }
@@ -371,9 +371,9 @@ processInt (const char *base0, const cha
       /* We have a number representable as an unsigned integer quantity.
          For consistency with the C treatment, we will treat it as an
 	 anonymous modular (unsigned) quantity.  Alas, the types are such
-	 that we need to store .val as a signed quantity.  Sorry
-         for the mess, but C doesn't officially guarantee that a simple
-         assignment does the trick (no, it doesn't; read the reference manual).
+	 that we need to store .val as a signed quantity.  Sorry for the
+         mess, but C doesn't officially guarantee that a simple assignment
+         does the trick (no, it doesn't; read the reference manual).
        */
       yylval.typed_val.type
 	= builtin_type (parse_gdbarch)->builtin_unsigned_long;
@@ -409,19 +409,19 @@ processReal (const char *num0)
 }
 
 
-/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
-   resulting string is valid until the next call to ada_parse.  It differs
-   from NAME0 in that:
+/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.
+   The resulting string is valid until the next call to ada_parse.
+   It differs from NAME0 in that:
     + Characters between '...' or <...> are transfered verbatim to 
       yylval.ssym.
-    + <, >, and trailing "'" characters in quoted sequences are removed
-      (a leading quote is preserved to indicate that the name is not to be
-      GNAT-encoded).
+    + <, >, and trailing "'" characters in quoted sequences are
+      removed (a leading quote is preserved to indicate that the name
+      is not to be GNAT-encoded).
     + Unquoted whitespace is removed.
     + Unquoted alphabetic characters are mapped to lower case.
-   Result is returned as a struct stoken, but for convenience, the string
-   is also null-terminated.  Result string valid until the next call of
-   ada_parse.
+   Result is returned as a struct stoken, but for convenience, the
+   string is also null-terminated.  Result string valid until the next
+   call of ada_parse.
  */
 static struct stoken
 processId (const char *name0, int len)
@@ -518,8 +518,8 @@ processString (const char *text, int len
 
 /* Returns the position within STR of the '.' in a
    '.{WHITE}*all' component of a dotted name, or -1 if there is none.
-   Note: we actually don't need this routine, since 'all' can never be an
-   Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
+   Note: we actually don't need this routine, since 'all' can never be
+   an Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
    must fail, and will eventually be interpreted as (foo).all or
    (foo).all.x.  However, this does avoid an extraneous lookup. */
 
@@ -543,8 +543,8 @@ find_dot_all (const char *str)
   return -1;
 }
 
-/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
-   case.  */
+/* Returns non-zero iff string SUBSEQ matches a subsequence of STR,
+   ignoring case.  */
 
 static int
 subseqMatch (const char *subseq, const char *str)
Index: ada-tasks.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-tasks.c,v
retrieving revision 1.36
diff -u -p -u -p -r1.36 ada-tasks.c
--- ada-tasks.c	7 Jan 2011 19:36:14 -0000	1.36
+++ ada-tasks.c	12 Jan 2011 03:12:28 -0000
@@ -125,12 +125,12 @@ struct tcb_fieldnos
   int call_self;
 };
 
-/* The type description for the ATCB record and subrecords, and
-   the associated tcb_fieldnos.  For efficiency reasons, these are made
+/* The type description for the ATCB record and subrecords, and the
+   associated tcb_fieldnos.  For efficiency reasons, these are made
    static globals so that we can compute them only once the first time
-   and reuse them later.  Set to NULL if the types haven't been computed
-   yet, or if they may be obsolete (for instance after having loaded
-   a new binary).  */
+   and reuse them later.  Set to NULL if the types haven't been
+   computed yet, or if they may be obsolete (for instance after having
+   loaded a new binary).  */
 
 static struct type *atcb_type = NULL;
 static struct type *atcb_common_type = NULL;
@@ -401,8 +401,8 @@ get_tcb_types_info (struct type **atcb_t
     {
       /* In Ravenscar run-time libs, the  ATCB does not have a dynamic
          size, so the symbol name differs.  */
-      atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL, VAR_DOMAIN,
-					    language_c, NULL);
+      atcb_sym = lookup_symbol_in_language (atcb_name_fixed, NULL,
+					    VAR_DOMAIN, language_c, NULL);
 
       if (atcb_sym == NULL || atcb_sym->type == NULL)
         error (_("Cannot find Ada_Task_Control_Block type. Aborting"));
@@ -467,9 +467,9 @@ get_tcb_types_info (struct type **atcb_t
   *atcb_fieldnos = fieldnos;
 }
 
-/* Build the PTID of the task from its COMMON_VALUE, which is the "Common"
-   component of its ATCB record.  This PTID needs to match the PTID used
-   by the thread layer.  */
+/* Build the PTID of the task from its COMMON_VALUE, which is the
+   "Common" component of its ATCB record.  This PTID needs to match
+   the PTID used by the thread layer.  */
 
 static ptid_t
 ptid_from_atcb_common (struct value *common_value)
@@ -490,9 +490,9 @@ ptid_from_atcb_common (struct value *com
   return ptid;
 }
 
-/* Read the ATCB data of a given task given its TASK_ID (which is in practice
-   the address of its assocated ATCB record), and store the result inside
-   TASK_INFO.  */
+/* Read the ATCB data of a given task given its TASK_ID (which is in
+   practice the address of its assocated ATCB record), and store the
+   result inside TASK_INFO.  */
 
 static void
 read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
@@ -522,14 +522,14 @@ read_atcb (CORE_ADDR task_id, struct ada
      string, or a thin array of characters.  Older versions of GNAT used
      to use fat strings, and therefore did not need an extra field in
      the ATCB to store the string length.  For efficiency reasons, newer
-     versions of GNAT replaced the fat string by a static buffer, but this
-     also required the addition of a new field named "Image_Len" containing
-     the length of the task name.  The method used to extract the task name
-     is selected depending on the existence of this field.
+     versions of GNAT replaced the fat string by a static buffer, but
+     this also required the addition of a new field named "Image_Len"
+     containing the length of the task name.  The method used to extract
+     the task name is selected depending on the existence of this field.
 
      In some run-time libs (e.g. Ravenscar), the name is not in the ATCB;
-     we may want to get it from the first user frame of the stack.  For now,
-     we just give a dummy name.  */
+     we may want to get it from the first user frame of the stack.  For
+     now, we just give a dummy name.  */
 
   if (fieldno.image_len == -1)
     {
@@ -613,16 +613,16 @@ read_atcb (CORE_ADDR task_id, struct ada
         }
     }
 
-  /* And finally, compute the task ptid.  Note that there are situations
-     where this cannot be determined:
+  /* And finally, compute the task ptid.  Note that there are
+     situations where this cannot be determined:
        - The task is no longer alive - the ptid is irrelevant;
        - We are debugging a core file - the thread is not always
          completely preserved for us to link back a task to its
          underlying thread.  Since we do not support task switching
          when debugging core files anyway, we don't need to compute
          that task ptid.
-     In either case, we don't need that ptid, and it is just good enough
-     to set it to null_ptid.  */
+     In either case, we don't need that ptid, and it is just good
+     enough to set it to null_ptid.  */
 
   if (target_has_execution && ada_task_is_alive (task_info))
     task_info->ptid = ptid_from_atcb_common (common_value);
@@ -658,11 +658,11 @@ read_known_tasks_array (void)
   /* Step 1: Clear the current list, if necessary.  */
   VEC_truncate (ada_task_info_s, task_list, 0);
 
-  /* If the application does not use task, then no more needs to be done.
-     It is important to have the task list cleared (see above) before we
-     return, as we don't want a stale task list to be used...  This can
-     happen for instance when debugging a non-multitasking program after
-     having debugged a multitasking one.  */
+  /* If the application does not use task, then no more needs to be
+     done.  It is important to have the task list cleared (see above)
+     before we return, as we don't want a stale task list to be
+     used...  This can happen for instance when debugging a non-
+     multitasking program after having debugged a multitasking one.  */
   if (known_tasks_addr == 0)
     return 0;
 
@@ -681,8 +681,8 @@ read_known_tasks_array (void)
         add_ada_task (task_id);
     }
 
-  /* Step 3: Unset stale_task_list_p, to avoid re-reading the Known_Tasks
-     array unless needed.  Then report a success.  */
+  /* Step 3: Unset stale_task_list_p, to avoid re-reading the
+     Known_Tasks array unless needed.  Then report a success.  */
   stale_task_list_p = 0;
 
   return 1;
@@ -723,8 +723,8 @@ short_task_info (int taskno)
 
   gdb_assert (task_info != NULL);
 
-  /* Print a star if this task is the current task (or the task currently
-     selected).  */
+  /* Print a star if this task is the current task (or the task
+     currently selected).  */
 
   active_task_p = ptid_equal (task_info->ptid, inferior_ptid);
   if (active_task_p)
Index: ada-typeprint.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-typeprint.c,v
retrieving revision 1.40
diff -u -p -u -p -r1.40 ada-typeprint.c
--- ada-typeprint.c	1 Jan 2011 15:32:56 -0000	1.40
+++ ada-typeprint.c	12 Jan 2011 03:12:28 -0000
@@ -38,8 +38,8 @@
 #include "gdb_string.h"
 #include <errno.h>
 
-static int print_selected_record_field_types (struct type *, struct type *,
-					      int, int,
+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 *,
@@ -132,11 +132,11 @@ print_range (struct type *type, struct u
 	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);
+	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);
+	ada_print_scalar (target_type,
+			  ada_discrete_type_high_bound (type), stream);
       }
       break;
     default:
@@ -161,14 +161,14 @@ print_range_bound (struct type *type, ch
       /* STABS decodes all range types which bounds are 0 .. -1 as
          unsigned integers (ie. the type code is TYPE_CODE_INT, not
          TYPE_CODE_RANGE).  Unfortunately, ada_print_scalar() relies
-         on the unsigned flag to determine whether the bound should
-         be printed as a signed or an unsigned value.  This causes
-         the upper bound of the 0 .. -1 range types to be printed as
-         a very large unsigned number instead of -1.
-         To workaround this stabs deficiency, we replace the TYPE by NULL
-         to indicate default output when we detect that the bound is negative,
-         and the type is a TYPE_CODE_INT.  The bound is negative when
-         'm' is the last character of the number scanned in BOUNDS.  */
+         on the unsigned flag to determine whether the bound should be
+         printed as a signed or an unsigned value.  This causes the
+         upper bound of the 0 .. -1 range types to be printed as a
+         very large unsigned number instead of -1.  To workaround this
+         stabs deficiency, we replace the TYPE by NULL to indicate
+         default output when we detect that the bound is negative, and
+         the type is a TYPE_CODE_INT.  The bound is negative when 'm'
+         is the last character of the number scanned in BOUNDS.  */
       if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
 	type = NULL;
       ada_print_scalar (type, B, stream);
@@ -460,8 +460,8 @@ print_choices (struct type *type, int fi
 	  {
 	    LONGEST L, U;
 
-	    if (!ada_scan_number (name, p + 1, &L, &p)
-		|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
+	    if (!ada_scan_number (name, p + 1, &L, &p) || name[p] != 'T'
+		|| !ada_scan_number (name, p + 1, &U, &p))
 	      goto Huh;
 	    ada_print_scalar (val_type, L, stream);
 	    fprintf_filtered (stream, " .. ");
@@ -481,12 +481,12 @@ Huh:
 }
 
 /* Assuming that field FIELD_NUM of TYPE represents variants whose
-   discriminant is contained in OUTER_TYPE, print its components on STREAM.
-   LEVEL is the recursion (indentation) level, in case any of the fields
-   themselves have nested structure, and SHOW is the number of levels of 
-   internal structure to show (see ada_print_type).  For this purpose,
-   fields nested in a variant part are taken to be at the same level as
-   the fields immediately outside the variant part.  */
+   discriminant is contained in OUTER_TYPE, print its components on
+   STREAM.  LEVEL is the recursion (indentation) level, in case any of
+   the fields themselves have nested structure, and SHOW is the number
+   of levels of internal structure to show (see ada_print_type).  For
+   this purpose, fields nested in a variant part are taken to be at
+   the same level as the fields immediately outside the variant part.  */
 
 static void
 print_variant_clauses (struct type *type, int field_num,
@@ -558,8 +558,8 @@ print_variant_part (struct type *type, i
 
 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)
+				   int fld0, int fld1, struct ui_file *stream,
+				   int show, int level)
 {
   int i, flds;
 
Index: ada-valprint.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-valprint.c,v
retrieving revision 1.72
diff -u -p -u -p -r1.72 ada-valprint.c
--- ada-valprint.c	10 Jan 2011 06:07:10 -0000	1.72
+++ ada-valprint.c	12 Jan 2011 03:12:28 -0000
@@ -36,8 +36,8 @@
 #include "exceptions.h"
 #include "objfiles.h"
 
-static void print_record (struct type *, const gdb_byte *, struct ui_file *,
-			  int,
+static void print_record (struct type *, const gdb_byte *,
+			  struct ui_file *, int,
 			  const struct value *,
 			  const struct value_print_options *);
 
@@ -50,9 +50,9 @@ static int print_field_values (struct ty
 
 static void adjust_type_signedness (struct type *);
 
-static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
-			    struct ui_file *, int,
-			    const struct value *,
+static int ada_val_print_1 (struct type *, const gdb_byte *, int,
+			    CORE_ADDR, struct ui_file *,
+			    int, const struct value *,
 			    const struct value_print_options *);
 
 
@@ -65,10 +65,10 @@ adjust_type_signedness (struct type *typ
     TYPE_UNSIGNED (type) = 1;
 }
 
-/* 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.  */
+/* 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
 print_optional_low_bound (struct ui_file *stream, struct type *type,
@@ -133,10 +133,10 @@ print_optional_low_bound (struct ui_file
     TYPE must have been decoded (as by ada_coerce_to_simple_array).  */
 
 static void
-val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
+val_print_packed_array_elements (struct type *type,
+				 const gdb_byte *valaddr,
 				 int bitoffset, struct ui_file *stream,
-				 int recurse,
-				 const struct value *val,
+				 int recurse, const struct value *val,
 				 const struct value_print_options *options)
 {
   unsigned int i;
@@ -457,9 +457,9 @@ ada_print_scalar (struct type *type, LON
    TYPE_LEN is the length (1 or 2) of the character type.  */
 
 static void
-printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
-	  unsigned int length, int force_ellipses, int type_len,
-	  const struct value_print_options *options)
+printstr (struct ui_file *stream, struct type *elttype,
+	  const gdb_byte *string, unsigned int length, int force_ellipses,
+	  int type_len, const struct value_print_options *options)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
   unsigned int i;
@@ -553,17 +553,17 @@ ada_printstr (struct ui_file *stream, st
 	      const char *encoding, int force_ellipses,
 	      const struct value_print_options *options)
 {
-  printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
-	    options);
+  printstr (stream, type, string, length, force_ellipses,
+	    TYPE_LENGTH (type), options);
 }
 
 
-/* Print data of type TYPE located at VALADDR (within GDB), which came from
-   the inferior at address ADDRESS, onto stdio stream STREAM according to
-   OPTIONS.  The data at VALADDR is in target byte order.
+/* Print data of type TYPE located at VALADDR (within GDB), which came
+   from the inferior at address ADDRESS, onto stdio stream STREAM
+   according to OPTIONS.  The data at VALADDR is in target byte order.
 
-   If the data is printed as a string, returns the number of string characters
-   printed.
+   If the data is printed as a string, returns the number of string
+   characters printed.
 
    RECURSE indicates the amount of indentation to supply before
    continuation lines; this amount is roughly twice the value of RECURSE.  */
@@ -597,8 +597,8 @@ ada_val_print (struct type *type, const 
 
 static int
 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
-		     CORE_ADDR address, struct ui_file *stream, int recurse,
-		     const struct value *val,
+		     CORE_ADDR address, struct ui_file *stream,
+		     int recurse, const struct value *val,
 		     const struct value_print_options *options)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
@@ -695,9 +695,9 @@ ada_val_print_1 (struct type *type, cons
 	  retn = 0;
 	}
       else
-	retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
-				value_address (val), stream, recurse,
-				NULL, options);
+	retn = ada_val_print_1 (value_type (val), value_contents (val),
+				0, value_address (val), stream,
+				recurse, NULL, options);
       value_free_to_mark (mark);
       return retn;
     }
@@ -709,8 +709,8 @@ ada_val_print_1 (struct type *type, cons
   switch (TYPE_CODE (type))
     {
     default:
-      return c_val_print (type, valaddr0, embedded_offset, address, stream,
-			  recurse, original_value, options);
+      return c_val_print (type, valaddr0, embedded_offset, address,
+			  stream, recurse, original_value, options);
 
     case TYPE_CODE_PTR:
       {
@@ -747,9 +747,9 @@ ada_val_print_1 (struct type *type, cons
 
 	  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
+	      /* 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
@@ -846,8 +846,8 @@ ada_val_print_1 (struct type *type, cons
 
     case TYPE_CODE_FLT:
       if (options->format)
-	return c_val_print (type, valaddr0, embedded_offset, address, stream,
-			    recurse, original_value, options);
+	return c_val_print (type, valaddr0, embedded_offset, address,
+			    stream, recurse, original_value, options);
       else
 	ada_print_floating (valaddr0 + embedded_offset, type, stream);
       break;
@@ -871,11 +871,11 @@ ada_val_print_1 (struct type *type, cons
 				  recurse, original_value, options);
 
     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.  */
+      /* 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)
@@ -907,12 +907,12 @@ ada_val_print_1 (struct type *type, cons
 }
 
 static int
-print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
-		    struct ui_file *stream, int recurse,
-		    const struct value *val,
+print_variant_part (struct type *type, int field_num,
+		    const gdb_byte *valaddr, struct ui_file *stream,
+		    int recurse, const struct value *val,
 		    const struct value_print_options *options,
-		    int comma_needed,
-		    struct type *outer_type, const gdb_byte *outer_valaddr)
+		    int comma_needed, struct type *outer_type,
+		    const gdb_byte *outer_valaddr)
 {
   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
   int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
@@ -1002,12 +1002,12 @@ print_record (struct type *type, const g
    TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
    same meanings as in ada_print_value and ada_val_print.
 
-   OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
-   (used to get discriminant values when printing variant parts).
+   OUTER_TYPE and OUTER_VALADDR give type and address of enclosing
+   record (used to get discriminant values when printing variant parts).
 
-   COMMA_NEEDED is 1 if fields have been printed at the current recursion
-   level, so that a comma is needed before any field printed by this
-   call.
+   COMMA_NEEDED is 1 if fields have been printed at the current
+   recursion level, so that a comma is needed before any field printed
+   by this call.
 
    Returns 1 if COMMA_NEEDED or any fields were printed.  */
 
@@ -1016,8 +1016,8 @@ print_field_values (struct type *type, c
 		    struct ui_file *stream, int recurse,
 		    const struct value *val,
 		    const struct value_print_options *options,
-		    int comma_needed,
-		    struct type *outer_type, const gdb_byte *outer_valaddr)
+		    int comma_needed, struct type *outer_type,
+		    const gdb_byte *outer_valaddr)
 {
   int i, len;
 
@@ -1032,8 +1032,8 @@ print_field_values (struct type *type, c
 	{
 	  comma_needed =
 	    print_field_values (TYPE_FIELD_TYPE (type, i),
-				valaddr
-				+ TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
+				valaddr	+ TYPE_FIELD_BITPOS (type, i)
+				/ HOST_CHAR_BIT,
 				stream, recurse, val, options,
 				comma_needed, type, valaddr);
 	  continue;
@@ -1041,8 +1041,8 @@ print_field_values (struct type *type, c
       else if (ada_is_variant_part (type, i))
 	{
 	  comma_needed =
-	    print_variant_part (type, i, valaddr,
-				stream, recurse, val, options, comma_needed,
+	    print_variant_part (type, i, valaddr, stream,
+				recurse, val, options, comma_needed,
 				outer_type, outer_valaddr);
 	  continue;
 	}
@@ -1108,8 +1108,8 @@ print_field_values (struct type *type, c
 						  TYPE_FIELD_TYPE (type, i));
 	      opts = *options;
 	      opts.deref_ref = 0;
-	      val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
-			 stream, recurse + 1, v,
+	      val_print (TYPE_FIELD_TYPE (type, i), value_contents (v),
+			 0, 0, stream, recurse + 1, v,
 			 &opts, current_language);
 	    }
 	}
@@ -1118,8 +1118,8 @@ print_field_values (struct type *type, c
 	  struct value_print_options opts = *options;
 
 	  opts.deref_ref = 0;
-	  ada_val_print (TYPE_FIELD_TYPE (type, i),
-			 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
+	  ada_val_print (TYPE_FIELD_TYPE (type, i), valaddr
+			 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
 			 0, 0, stream, recurse + 1, val, &opts);
 	}
       annotate_field_end ();

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]