2010-12-31 Michael Snyder <msnyder@vmware.com>

	* charset.c: Comment cleanup and long line wrapping.
	* charset.h: Ditto.
	* c-lang.c: Ditto.
	* c-lang.h: Ditto.
	* coff-pe-read.c: Ditto.
	* coff-pe-read.h: Ditto.
	* coffread.c: Ditto.
	* command.h: Ditto.
	* complaints.c: Ditto.
	* complaints.h: Ditto.
	* completer.c: Ditto.
	* completer.h: Ditto.
	* corefile.c: Ditto.
	* corelow.c: Ditto.
	* core-regset.c: Ditto.
	* cp-abi.c: Ditto.
	* cp-abi.h: Ditto.
	* cp-namespace.c: Ditto.
	* cp-support.c: Ditto.
	* cp-support.h: Ditto.
	* cp-valprint.c: Ditto.
	* cp-typeprint.c: Ditto.
	* c-valprint.c: Ditto.

1 files changed, 124 insertions, 86 deletions

diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 20ac6336cd2..e583a322871 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -36,14 +36,17 @@
    stream STREAM.  */
 
 static void
-print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address,
-				struct ui_file *stream, int addressprint)
+print_function_pointer_address (struct gdbarch *gdbarch,
+				CORE_ADDR address,
+				struct ui_file *stream,
+				int addressprint)
 {
-  CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
-							    &current_target);
+  CORE_ADDR func_addr
+    = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
+					  &current_target);
 
-  /* If the function pointer is represented by a description, print the
-     address of the description.  */
+  /* If the function pointer is represented by a description, print
+     the address of the description.  */
   if (addressprint && func_addr != address)
     {
       fputs_filtered ("@", stream);
@@ -69,8 +72,8 @@ textual_name (const char *name)
 /* Apply a heuristic to decide whether an array of TYPE or a pointer
    to TYPE should be printed as a textual string.  Return non-zero if
    it should, or zero if it should be treated as an array of integers
-   or pointer to integers.  FORMAT is the current format letter,
-   or 0 if none.
+   or pointer to integers.  FORMAT is the current format letter, or 0
+   if none.
 
    We guess that "char" is a character.  Explicitly signed and
    unsigned character types are also characters.  Integer data from
@@ -119,8 +122,8 @@ c_textual_element_type (struct type *type, char format)
 
   if (format == 's')
     {
-      /* Print this as a string if we can manage it.  For now, no
-	 wide character support.  */
+      /* Print this as a string if we can manage it.  For now, no wide
+	 character support.  */
       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 	  && TYPE_LENGTH (true_type) == 1)
 	return 1;
@@ -140,22 +143,23 @@ c_textual_element_type (struct type *type, char format)
 }
 
 
-/* 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 are a string pointer, returns the number of string characters
-   printed.  */
+   If the data are a string pointer, returns the number of string
+   characters printed.  */
 
 int
-c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
-	     CORE_ADDR address, struct ui_file *stream, int recurse,
+c_val_print (struct type *type, const gdb_byte *valaddr,
+	     int embedded_offset, CORE_ADDR address,
+	     struct ui_file *stream, int recurse,
 	     const struct value *original_value,
 	     const struct value_print_options *options)
 {
   struct gdbarch *gdbarch = get_type_arch (type);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  unsigned int i = 0;	/* Number of characters printed */
+  unsigned int i = 0;	/* Number of characters printed.  */
   unsigned len;
   struct type *elttype, *unresolved_elttype;
   struct type *unresolved_type = type;
@@ -185,13 +189,14 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 
 	  /* Print arrays of textual chars with a string syntax, as
 	     long as the entire array is valid.  */
-          if (c_textual_element_type (unresolved_elttype, options->format)
+          if (c_textual_element_type (unresolved_elttype,
+				      options->format)
 	      && value_bits_valid (original_value,
 				   TARGET_CHAR_BIT * embedded_offset,
 				   TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 	    {
-	      /* If requested, look for the first null char and only print
-	         elements up to it.  */
+	      /* If requested, look for the first null char and only
+	         print elements up to it.  */
 	      if (options->stop_print_at_null)
 		{
 		  unsigned int temp_len;
@@ -216,24 +221,28 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	    {
 	      fprintf_filtered (stream, "{");
 	      /* If this is a virtual function table, print the 0th
-	         entry specially, and the rest of the members normally.  */
+	         entry specially, and the rest of the members
+	         normally.  */
 	      if (cp_is_vtbl_ptr_type (elttype))
 		{
 		  i = 1;
-		  fprintf_filtered (stream, _("%d vtable entries"), len - 1);
+		  fprintf_filtered (stream, _("%d vtable entries"),
+				    len - 1);
 		}
 	      else
 		{
 		  i = 0;
 		}
 	      val_print_array_elements (type, valaddr + embedded_offset,
-					address + embedded_offset, stream,
-					recurse, original_value, options, i);
+					address + embedded_offset,
+					stream, recurse,
+					original_value, options, i);
 	      fprintf_filtered (stream, "}");
 	    }
 	  break;
 	}
-      /* Array of unspecified length: treat like pointer to first elt.  */
+      /* Array of unspecified length: treat like pointer to first
+	 elt.  */
       addr = address;
       goto print_unpacked_pointer;
 
@@ -262,7 +271,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	{
 	  /* Print the unmangled name if desired.  */
 	  /* Print vtable entry - we only get here if we ARE using
-	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
+	     -fvtable_thunks.  (Otherwise, look under
+	     TYPE_CODE_STRUCT.)  */
 	  CORE_ADDR addr
 	    = extract_typed_address (valaddr + embedded_offset, type);
 
@@ -281,7 +291,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	      /* Try to print what function it points to.  */
 	      print_function_pointer_address (gdbarch, addr, stream,
 					      options->addressprint);
-	      /* Return value is irrelevant except for string pointers.  */
+	      /* Return value is irrelevant except for string
+		 pointers.  */
 	      return (0);
 	    }
 
@@ -291,16 +302,20 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	  /* For a pointer to a textual type, also print the string
 	     pointed to, unless pointer is null.  */
 
-	  if (c_textual_element_type (unresolved_elttype, options->format)
+	  if (c_textual_element_type (unresolved_elttype,
+				      options->format)
 	      && addr != 0)
 	    {
-	      i = val_print_string (unresolved_elttype, NULL, addr, -1, stream,
-				    options);
+	      i = val_print_string (unresolved_elttype, NULL,
+				    addr, -1,
+				    stream, options);
 	    }
 	  else if (cp_is_vtbl_member (type))
 	    {
-	      /* print vtbl's nicely */
-	      CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
+	      /* Print vtbl's nicely.  */
+	      CORE_ADDR vt_address = unpack_pointer (type,
+						     valaddr
+						     + embedded_offset);
 
 	      struct minimal_symbol *msymbol =
 	      lookup_minimal_symbol_by_pc (vt_address);
@@ -320,8 +335,9 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 		  int is_this_fld;
 
 		  if (msymbol != NULL)
-		    wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), block,
-					  VAR_DOMAIN, &is_this_fld);
+		    wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
+					  block, VAR_DOMAIN,
+					  &is_this_fld);
 
 		  if (wsym)
 		    {
@@ -332,8 +348,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 		      wtype = unresolved_elttype;
 		    }
 		  vt_val = value_at (wtype, vt_address);
-		  common_val_print (vt_val, stream, recurse + 1, options,
-				    current_language);
+		  common_val_print (vt_val, stream, recurse + 1,
+				    options, current_language);
 		  if (options->pretty)
 		    {
 		      fprintf_filtered (stream, "\n");
@@ -342,9 +358,10 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 		}
 	    }
 
-	  /* Return number of characters printed, including the terminating
-	     '\0' if we reached the end.  val_print_string takes care including
-	     the terminating '\0' if necessary.  */
+	  /* Return number of characters printed, including the
+	     terminating '\0' if we reached the end.  val_print_string
+	     takes care including the terminating '\0' if
+	     necessary.  */
 	  return i;
 	}
       break;
@@ -392,10 +409,13 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	{
 	  /* Print the unmangled name if desired.  */
 	  /* Print vtable entry - we only get here if NOT using
-	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_PTR.) */
-	  int offset = (embedded_offset +
-			TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
-	  struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
+	     -fvtable_thunks.  (Otherwise, look under
+	     TYPE_CODE_PTR.)  */
+	  int offset = (embedded_offset
+			+ TYPE_FIELD_BITPOS (type,
+					     VTBL_FNADDR_OFFSET) / 8);
+	  struct type *field_type = TYPE_FIELD_TYPE (type,
+						     VTBL_FNADDR_OFFSET);
 	  CORE_ADDR addr
 	    = extract_typed_address (valaddr + offset, field_type);
 
@@ -404,8 +424,10 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	}
       else
 	cp_print_value_fields_rtti (type, valaddr,
-				    embedded_offset, address, stream,
-				    recurse, original_value, options, NULL, 0);
+				    embedded_offset, address,
+				    stream, recurse,
+				    original_value, options,
+				    NULL, 0);
       break;
 
     case TYPE_CODE_ENUM:
@@ -440,7 +462,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	  print_scalar_formatted (valaddr + embedded_offset, type,
 				  options, 0, stream);
       else
-	val_print_type_code_flags (type, valaddr + embedded_offset, stream);
+	val_print_type_code_flags (type, valaddr + embedded_offset,
+				   stream);
       break;
 
     case TYPE_CODE_FUNC:
@@ -451,8 +474,9 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 				  options, 0, stream);
 	  break;
 	}
-      /* FIXME, we should consider, at least for ANSI C language, eliminating
-         the distinction made between FUNCs and POINTERs to FUNCs.  */
+      /* FIXME, we should consider, at least for ANSI C language,
+         eliminating the distinction made between FUNCs and POINTERs
+         to FUNCs.  */
       fprintf_filtered (stream, "{");
       type_print (type, "", stream, -1);
       fprintf_filtered (stream, "} ");
@@ -483,12 +507,12 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 
     case TYPE_CODE_RANGE:
       /* FIXME: create_range_type does not set the unsigned bit in a
-         range type (I think it probably should copy it from the target
-         type), so we won't print values which are too large to
+         range type (I think it probably should copy it from the
+         target type), so we won't print values which are too large to
          fit in a signed integer correctly.  */
       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
-         print with the target type, though, because the size of our type
-         and the target type might differ).  */
+         print with the target type, though, because the size of our
+         type and the target type might differ).  */
       /* FALLTHROUGH */
 
     case TYPE_CODE_INT:
@@ -503,15 +527,18 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	}
       else
 	{
-	  val_print_type_code_int (type, valaddr + embedded_offset, stream);
-	  /* C and C++ has no single byte int type, char is used instead.
-	     Since we don't know whether the value is really intended to
-	     be used as an integer or a character, print the character
-	     equivalent as well.  */
+	  val_print_type_code_int (type, valaddr + embedded_offset,
+				   stream);
+	  /* C and C++ has no single byte int type, char is used
+	     instead.  Since we don't know whether the value is really
+	     intended to be used as an integer or a character, print
+	     the character equivalent as well.  */
 	  if (c_textual_element_type (unresolved_type, options->format))
 	    {
 	      fputs_filtered (" ", stream);
-	      LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
+	      LA_PRINT_CHAR ((unsigned char) unpack_long (type,
+							  valaddr
+							  + embedded_offset),
 			     unresolved_type, stream);
 	    }
 	}
@@ -555,7 +582,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 	print_scalar_formatted (valaddr + embedded_offset, type,
 				options, 0, stream);
       else
-	print_decimal_floating (valaddr + embedded_offset, type, stream);
+	print_decimal_floating (valaddr + embedded_offset,
+				type, stream);
       break;
 
     case TYPE_CODE_VOID:
@@ -567,9 +595,10 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
       break;
 
     case TYPE_CODE_UNDEF:
-      /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
-         dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
-         and no complete type for struct foo in that file.  */
+      /* This happens (without TYPE_FLAG_STUB set) on systems which
+         don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
+         "struct foo *bar" and no complete type for struct foo in that
+         file.  */
       fprintf_filtered (stream, _("<incomplete type>"));
       break;
 
@@ -579,7 +608,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 				TYPE_TARGET_TYPE (type),
 				options, 0, stream);
       else
-	print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
+	print_floating (valaddr + embedded_offset,
+			TYPE_TARGET_TYPE (type),
 			stream);
       fprintf_filtered (stream, " + ");
       if (options->format)
@@ -596,7 +626,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
       break;
 
     default:
-      error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type));
+      error (_("Invalid C/C++ type code %d in symbol table."),
+	     TYPE_CODE (type));
     }
   gdb_flush (stream);
   return (0);
@@ -635,10 +666,11 @@ c_value_print (struct value *val, struct ui_file *stream,
       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 	  && TYPE_NAME (val_type) == NULL
 	  && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
-	  && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)), "char") == 0
+	  && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
+		      "char") == 0
 	      || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 	{
-	  /* Print nothing */
+	  /* Print nothing.  */
 	}
       else if (options->objectprint
 	       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
@@ -647,35 +679,39 @@ c_value_print (struct value *val, struct ui_file *stream,
 	  if (TYPE_CODE(type) == TYPE_CODE_REF)
 	    {
 	      /* Copy value, change to pointer, so we don't get an
-	       * error about a non-pointer type in value_rtti_target_type
-	       */
+	         error about a non-pointer type in
+	         value_rtti_target_type.  */
 	      struct value *temparg;
 	      temparg=value_copy(val);
-	      deprecated_set_value_type (temparg, lookup_pointer_type (TYPE_TARGET_TYPE(type)));
-	      val=temparg;
+	      deprecated_set_value_type
+		(temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
+	      val = temparg;
 	    }
-	  /* Pointer to class, check real type of object */
+	  /* Pointer to class, check real type of object.  */
 	  fprintf_filtered (stream, "(");
-          real_type = value_rtti_target_type (val, &full, &top, &using_enc);
+          real_type = value_rtti_target_type (val, &full,
+					      &top, &using_enc);
           if (real_type)
 	    {
-	      /* RTTI entry found */
+	      /* RTTI entry found.  */
               if (TYPE_CODE (type) == TYPE_CODE_PTR)
                 {
-                  /* create a pointer type pointing to the real type */
+                  /* Create a pointer type pointing to the real
+		     type.  */
                   type = lookup_pointer_type (real_type);
                 }
               else
                 {
-                  /* create a reference type referencing the real type */
+                  /* Create a reference type referencing the real
+		     type.  */
                   type = lookup_reference_type (real_type);
                 }
-	      /* JYG: Need to adjust pointer value. */
+	      /* JYG: Need to adjust pointer value.  */
 	      /* NOTE: cagney/2005-01-02: THIS IS BOGUS.  */
               value_contents_writeable (val)[0] -= top;
 
               /* Note: When we look up RTTI entries, we don't get any 
-                 information on const or volatile attributes */
+                 information on const or volatile attributes.  */
             }
           type_print (type, "", stream, -1);
 	  fprintf_filtered (stream, ") ");
@@ -695,26 +731,28 @@ c_value_print (struct value *val, struct ui_file *stream,
 
   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
     {
-      /* Attempt to determine real type of object */
+      /* Attempt to determine real type of object.  */
       real_type = value_rtti_type (val, &full, &top, &using_enc);
       if (real_type)
 	{
-	  /* We have RTTI information, so use it */
-	  val = value_full_object (val, real_type, full, top, using_enc);
+	  /* We have RTTI information, so use it.  */
+	  val = value_full_object (val, real_type, 
+				   full, top, using_enc);
 	  fprintf_filtered (stream, "(%s%s) ",
 			    TYPE_NAME (real_type),
 			    full ? "" : _(" [incomplete object]"));
-	  /* Print out object: enclosing type is same as real_type if full */
+	  /* Print out object: enclosing type is same as real_type if
+	     full.  */
 	  return val_print (value_enclosing_type (val),
 			    value_contents_for_printing (val), 0,
 			    value_address (val), stream, 0,
 			    val, &opts, current_language);
-          /* Note: When we look up RTTI entries, we don't get any information on
-             const or volatile attributes */
+          /* Note: When we look up RTTI entries, we don't get any
+             information on const or volatile attributes.  */
 	}
       else if (type != check_typedef (value_enclosing_type (val)))
 	{
-	  /* No RTTI information, so let's do our best */
+	  /* No RTTI information, so let's do our best.  */
 	  fprintf_filtered (stream, "(%s ?) ",
 			    TYPE_NAME (value_enclosing_type (val)));
 	  return val_print (value_enclosing_type (val),
@@ -722,7 +760,7 @@ c_value_print (struct value *val, struct ui_file *stream,
 			    value_address (val), stream, 0,
 			    val, &opts, current_language);
 	}
-      /* Otherwise, we end up at the return outside this "if" */
+      /* Otherwise, we end up at the return outside this "if".  */
     }
 
   return val_print (val_type, value_contents_for_printing (val),