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

	* ada-lang.c: Comment cleanup, mostly periods and spaces.
	* ada-lang.h: Ditto.
	* ada-tasks.c: Ditto.
	* ada-valprint.c: Ditto.
	* aix-threads.c: Ditto.
	* alpha-linux-nat.c: Ditto.
	* alpha-linux-tdep.c: Ditto.
	* alpha-mdebug-tdep.c: Ditto.
	* alpha-nat.c: Ditto.
	* alpha-osf1-tdep.c: Ditto.
	* alpha-tdep.c: Ditto.
	* alphabsd-nat.c: Ditto.
	* alphabsd-tdep.c: Ditto.
	* amd64-darwin-tdep.c: Ditto.
	* amd64-linux-nat.c: Ditto.
	* amd64-linux-tdep.c: Ditto.
	* amd64-sol2-tdep.c: Ditto.
	* amd64-tdep.c: Ditto.
	* amd64-fbsd-tdep.c: Ditto.
	* amd64-nbsd-tdep.c: Ditto.
	* amd64-obsd-tdep.c: Ditto.
	* amd64-linux-nat.c: Ditto.
	* amd64-linux-tdep.c: Ditto.
	* arm-tdep.c: Ditto.
	* arm-tdep.h: Ditto.
	* armnbsd-nat.c: Ditto.
	* avr-tdep.c: Ditto.
	* bfin-tdep.c: Ditto.
	* bsd-kvm.c: Ditto.
	* c-typeprintc: Ditto.
	* c-valprint.c: Ditto.
	* coff-pe-read.h: Ditto.
	* coffreead.c: Ditto.
	* cris-tdep.c: Ditto.
	* d-lang.c: Ditto.
	* darwin-nat-info.c: Ditto.
	* darwin-nat.c: Ditto.
	* dbug-rom.c: Ditto.
	* dbxread.c: Ditto.
	* dcache.c: Ditto.
	* dcache.h: Ditto.
	* dec-thread.c: Ditto.
	* defs.h: Ditto.
	* demangle.c: Ditto.
	* dicos-tdep.c: Ditto.
	* dictionary.c: Ditto.
	* dictionary.h: Ditto.
	* dink32-rom.c: Ditto.
	* disasm.c: Ditto.
	* doublest.c: Ditto.
	* dsrec.c: Ditto.
	* dummy-frame.c: Ditto.
	* dwarf2-frame.c: Ditto.
	* dwarf2expr.c: Ditto.
	* dwarf2loc.c: Ditto.
	* dwarf2read.c: Ditto.
	* elfread.c: Ditto.
	* environ.c: Ditto.
	* eval.c: Ditto.
	* event-top.h: Ditto.
	* exceptions.c: Ditto.
	* exceptions.h: Ditto.
	* exec.c: Ditto.
	* expprint.c: Ditto.
	* expression.h: Ditto.
	* f-exp.y: Ditto.
	* f-lang.c: Ditto.
	* f-lang.h: Ditto.
	* f-typeprint.c: Ditto.
	* f-valprint.c: Ditto.
	* fbsd-nat.c: Ditto.
	* findvar.c: Ditto.
	* fork-child.c: Ditto.
	* frame.c: Ditto.
	* frame.h: Ditto.
	* frv-linux-tdep.c: Ditto.
	* frv-tdep.c: Ditto.
	* gcore.c: Ditto.
	* gdb-stabs.h: Ditto.
	* gdb_assert.h: Ditto.
	* gdb_string.h: Ditto.
	* gdb_thread_db.h: Ditto.
	* gdb_wait.h: Ditto.
	* gdbarch.sh: Ditto.
	* gdbcore.h: Ditto.
	* gdbthread.h: Ditto.
	* gdbtypes.c: Ditto.
	* gdbtypes.h: Ditto.
	* gnu-nat.c: Ditto.
	* gnu-nat.h: Ditto.
	* gnu-v2-abi.c: Ditto.
	* gnu-v3-abi.c: Ditto.
	* go32-nat.c: Ditto.
	* gdbarch.c: Regenerate.
	* gdbarch.h: Regenerate.

1 files changed, 80 insertions, 80 deletions

diff --git a/gdb/eval.c b/gdb/eval.c
index 8394623d79d..d3cb52c674a 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -27,8 +27,8 @@
 #include "expression.h"
 #include "target.h"
 #include "frame.h"
-#include "language.h"		/* For CAST_IS_CONVERSION */
-#include "f-lang.h"		/* for array bound stuff */
+#include "language.h"		/* For CAST_IS_CONVERSION.  */
+#include "f-lang.h"		/* For array bound stuff.  */
 #include "cp-abi.h"
 #include "infcall.h"
 #include "objc-lang.h"
@@ -52,7 +52,7 @@
 /* This is defined in valops.c */
 extern int overload_resolution;
 
-/* Prototypes for local functions. */
+/* Prototypes for local functions.  */
 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
 
@@ -110,7 +110,7 @@ parse_and_eval_address_1 (char **expptr)
 }
 
 /* Like parse_and_eval_address, but treats the value of the expression
-   as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
+   as an integer, not an address, returns a LONGEST, not a CORE_ADDR.  */
 LONGEST
 parse_and_eval_long (char *exp)
 {
@@ -288,7 +288,7 @@ extract_field_op (struct expression *exp, int *subexp)
 }
 
 /* If the next expression is an OP_LABELED, skips past it,
-   returning the label.  Otherwise, does nothing and returns NULL. */
+   returning the label.  Otherwise, does nothing and returns NULL.  */
 
 static char *
 get_label (struct expression *exp, int *pos)
@@ -329,7 +329,7 @@ evaluate_struct_tuple (struct value *struct_val,
       int bitpos, bitsize;
       bfd_byte *addr;
 
-      /* Skip past the labels, and count them. */
+      /* Skip past the labels, and count them.  */
       while (get_label (exp, pos) != NULL)
 	nlabels++;
 
@@ -390,7 +390,7 @@ evaluate_struct_tuple (struct value *struct_val,
 	    }
 	  else
 	    {
-	      /* Unlabelled tuple element - go to next field. */
+	      /* Unlabelled tuple element - go to next field.  */
 	      if (variantno >= 0)
 		{
 		  subfieldno++;
@@ -425,15 +425,15 @@ evaluate_struct_tuple (struct value *struct_val,
 	     The value fieldno is the index of the top-level (normal or
 	     anonymous union) field in struct_field, while the value
 	     subfieldno is the index of the actual real (named inner) field
-	     in substruct_type. */
+	     in substruct_type.  */
 
 	  field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
 	  if (val == 0)
 	    val = evaluate_subexp (field_type, exp, pos, noside);
 
-	  /* Now actually set the field in struct_val. */
+	  /* Now actually set the field in struct_val.  */
 
-	  /* Assign val to field fieldno. */
+	  /* Assign val to field fieldno.  */
 	  if (value_type (val) != field_type)
 	    val = value_cast (field_type, val);
 
@@ -852,7 +852,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	 We need a full value object returned here for whatis_exp ()
 	 to call evaluate_type () and then pass the full value to
 	 value_rtti_target_type () if we are dealing with a pointer
-	 or reference to a base class and print object is on. */
+	 or reference to a base class and print object is on.  */
 
       {
 	volatile struct gdb_exception except;
@@ -1004,7 +1004,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	      else
 		{
 		  if (index > high_bound)
-		    /* to avoid memory corruption */
+		    /* To avoid memory corruption.  */
 		    error (_("Too many array elements"));
 		  memcpy (value_contents_raw (array)
 			  + (index - low_bound) * element_size,
@@ -1025,7 +1025,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	  struct type *check_type = element_type;
 	  LONGEST low_bound, high_bound;
 
-	  /* get targettype of elementtype */
+	  /* Get targettype of elementtype.  */
 	  while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
 		 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
 	    check_type = TYPE_TARGET_TYPE (check_type);
@@ -1055,9 +1055,9 @@ evaluate_subexp_standard (struct type *expect_type,
 		  range_low_type = range_high_type = value_type (elem_val);
 		  range_low = range_high = value_as_long (elem_val);
 		}
-	      /* check types of elements to avoid mixture of elements from
+	      /* Check types of elements to avoid mixture of elements from
 	         different types. Also check if type of element is "compatible"
-	         with element type of powerset */
+	         with element type of powerset.  */
 	      if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
 		range_low_type = TYPE_TARGET_TYPE (range_low_type);
 	      if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
@@ -1065,7 +1065,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	      if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
 		  || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
 		      && (range_low_type != range_high_type)))
-		/* different element modes */
+		/* different element modes.  */
 		error (_("POWERSET tuple elements of different mode"));
 	      if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
 		  || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
@@ -1096,7 +1096,8 @@ evaluate_subexp_standard (struct type *expect_type,
       argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
       for (tem = 0; tem < nargs; tem++)
 	{
-	  /* Ensure that array expressions are coerced into pointer objects. */
+	  /* Ensure that array expressions are coerced into pointer
+	     objects.  */
 	  argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
 	}
       if (noside == EVAL_SKIP)
@@ -1213,7 +1214,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	   to lookup the symbol information for the method.  If we
 	   can't find any symbol information, then we'll use these to
 	   call the method, otherwise we can call the method
-	   directly. The msg_send_stret function is used in the special
+	   directly.  The msg_send_stret function is used in the special
 	   case of a method that returns a structure (Apple runtime 
 	   only).  */
 	if (gnu_runtime)
@@ -1236,15 +1237,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	else
 	  {
 	    msg_send = find_function_in_inferior ("objc_msgSend", NULL);
-	    /* Special dispatcher for methods returning structs */
+	    /* Special dispatcher for methods returning structs.  */
 	    msg_send_stret
 	      = find_function_in_inferior ("objc_msgSend_stret", NULL);
 	  }
 
-	/* Verify the target object responds to this method. The
+	/* Verify the target object responds to this method.  The
 	   standard top-level 'Object' class uses a different name for
 	   the verification method than the non-standard, but more
-	   often used, 'NSObject' class. Make sure we check for both. */
+	   often used, 'NSObject' class.  Make sure we check for both.  */
 
 	responds_selector
 	  = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
@@ -1265,7 +1266,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	  error (_("no 'methodFor:' or 'methodForSelector:' method"));
 
 	/* Call the verification method, to make sure that the target
-	 class implements the desired method. */
+	 class implements the desired method.  */
 
 	argvec[0] = msg_send;
 	argvec[1] = target;
@@ -1287,7 +1288,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	   function method that implements this selector for this
 	   class.  If we can find a symbol at that address, then we
 	   know the return type, parameter types etc.  (that's a good
-	   thing). */
+	   thing).  */
 
 	argvec[0] = msg_send;
 	argvec[1] = target;
@@ -1401,11 +1402,11 @@ evaluate_subexp_standard (struct type *expect_type,
 	  {
 	    /* If the return type doesn't look like a function type,
 	       call an error.  This can happen if somebody tries to
-	       turn a variable into a function call. This is here
+	       turn a variable into a function call.  This is here
 	       because people often want to call, eg, strcmp, which
 	       gdb doesn't know is a function.  If gdb isn't asked for
 	       it's opinion (ie. through "whatis"), it won't offer
-	       it. */
+	       it.  */
 
 	    struct type *type = value_type (called_method);
 
@@ -1456,13 +1457,13 @@ evaluate_subexp_standard (struct type *expect_type,
       op = exp->elts[*pos].opcode;
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       /* Allocate arg vector, including space for the function to be
-         called in argvec[0] and a terminating NULL */
+         called in argvec[0] and a terminating NULL.  */
       argvec = (struct value **)
 	alloca (sizeof (struct value *) * (nargs + 3));
       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
 	{
 	  nargs++;
-	  /* First, evaluate the structure into arg2 */
+	  /* First, evaluate the structure into arg2.  */
 	  pc2 = (*pos)++;
 
 	  if (noside == EVAL_SKIP)
@@ -1499,16 +1500,16 @@ evaluate_subexp_standard (struct type *expect_type,
 	  else
 	    arg1 = cplus_method_ptr_to_value (&arg2, arg1);
 
-	  /* Now, say which argument to start evaluating from */
+	  /* Now, say which argument to start evaluating from.  */
 	  tem = 2;
 	}
       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
 	{
-	  /* Hair for method invocations */
+	  /* Hair for method invocations.  */
 	  int tem2;
 
 	  nargs++;
-	  /* First, evaluate the structure into arg2 */
+	  /* First, evaluate the structure into arg2.  */
 	  pc2 = (*pos)++;
 	  tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
 	  *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
@@ -1560,7 +1561,7 @@ evaluate_subexp_standard (struct type *expect_type,
 		  arg2 = value;
 		}
 	    }
-	  /* Now, say which argument to start evaluating from */
+	  /* Now, say which argument to start evaluating from.  */
 	  tem = 2;
 	}
       else if (op == OP_SCOPE
@@ -1617,7 +1618,7 @@ evaluate_subexp_standard (struct type *expect_type,
         }
       else
 	{
-	  /* Non-method function call */
+	  /* Non-method function call.  */
 	  save_pos1 = *pos;
 	  tem = 1;
 
@@ -1647,14 +1648,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	    }
 	}
 
-      /* Evaluate arguments */
+      /* Evaluate arguments.  */
       for (; tem <= nargs; tem++)
 	{
-	  /* Ensure that array expressions are coerced into pointer objects. */
+	  /* Ensure that array expressions are coerced into pointer
+	     objects.  */
 	  argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
 	}
 
-      /* signal end of arglist */
+      /* Signal end of arglist.  */
       argvec[tem] = 0;
       if (op == OP_ADL_FUNC)
         {
@@ -1668,7 +1670,7 @@ evaluate_subexp_standard (struct type *expect_type,
           func_name = (char *) alloca (name_len + 1);
           strcpy (func_name, &exp->elts[string_pc + 1].string);
 
-          /* Prepare list of argument types for overload resolution */
+          /* Prepare list of argument types for overload resolution.  */
           arg_types = (struct type **)
 	    alloca (nargs * (sizeof (struct type *)));
           for (ix = 1; ix <= nargs; ix++)
@@ -1692,12 +1694,12 @@ evaluate_subexp_standard (struct type *expect_type,
 	  int static_memfuncp;
 	  char *tstr;
 
-	  /* Method invocation : stuff "this" as first parameter */
+	  /* Method invocation : stuff "this" as first parameter.  */
 	  argvec[1] = arg2;
 
 	  if (op != OP_SCOPE)
 	    {
-	      /* Name of method from expression */
+	      /* Name of method from expression.  */
 	      tstr = &exp->elts[pc2 + 2].string;
 	    }
 	  else
@@ -1707,10 +1709,10 @@ evaluate_subexp_standard (struct type *expect_type,
 				      == language_cplus))
 	    {
 	      /* Language is C++, do some overload resolution before
-		 evaluation */
+		 evaluation.  */
 	      struct value *valp = NULL;
 
-	      /* Prepare list of argument types for overload resolution */
+	      /* Prepare list of argument types for overload resolution.  */
 	      arg_types = (struct type **)
 		alloca (nargs * (sizeof (struct type *)));
 	      for (ix = 1; ix <= nargs; ix++)
@@ -1731,11 +1733,11 @@ evaluate_subexp_standard (struct type *expect_type,
 			 function_name);
 		}
 	      argvec[1] = arg2;	/* the ``this'' pointer */
-	      argvec[0] = valp;	/* use the method found after overload
-				   resolution */
+	      argvec[0] = valp;	/* Use the method found after overload
+				   resolution.  */
 	    }
 	  else
-	    /* Non-C++ case -- or no overload resolution */
+	    /* Non-C++ case -- or no overload resolution.  */
 	    {
 	      struct value *temp = arg2;
 
@@ -1767,16 +1769,16 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
 	{
-	  /* Non-member function being called */
+	  /* Non-member function being called.  */
           /* fn: This can only be done for C++ functions.  A C-style function
              in a C++ program, for instance, does not have the fields that 
-             are expected here */
+             are expected here.  */
 
 	  if (overload_resolution && (exp->language_defn->la_language
 				      == language_cplus))
 	    {
 	      /* Language is C++, do some overload resolution before
-		 evaluation */
+		 evaluation.  */
 	      struct symbol *symp;
 	      int no_adl = 0;
 
@@ -1787,7 +1789,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	      if (op == OP_VAR_VALUE)
 		function = exp->elts[save_pos1+2].symbol;
 
-	      /* Prepare list of argument types for overload resolution */
+	      /* Prepare list of argument types for overload resolution.  */
 	      arg_types = (struct type **)
 		alloca (nargs * (sizeof (struct type *)));
 	      for (ix = 1; ix <= nargs; ix++)
@@ -1802,7 +1804,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	      if (op == OP_VAR_VALUE)
 		{
-		  /* Now fix the expression being evaluated */
+		  /* Now fix the expression being evaluated.  */
 		  exp->elts[save_pos1+2].symbol = symp;
 		  argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
 							     noside);
@@ -1812,14 +1814,14 @@ evaluate_subexp_standard (struct type *expect_type,
 	    }
 	  else
 	    {
-	      /* Not C++, or no overload resolution allowed */
-	      /* nothing to be done; argvec already correctly set up */
+	      /* Not C++, or no overload resolution allowed.  */
+	      /* Nothing to be done; argvec already correctly set up.  */
 	    }
 	}
       else
 	{
-	  /* It is probably a C-style function */
-	  /* nothing to be done; argvec already correctly set up */
+	  /* It is probably a C-style function.  */
+	  /* Nothing to be done; argvec already correctly set up.  */
 	}
 
     do_call_it:
@@ -1832,10 +1834,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	{
 	  /* If the return type doesn't look like a function type, call an
 	     error.  This can happen if somebody tries to turn a variable into
-	     a function call. This is here because people often want to
+	     a function call.  This is here because people often want to
 	     call, eg, strcmp, which gdb doesn't know is a function.  If
 	     gdb isn't asked for it's opinion (ie. through "whatis"),
-	     it won't offer it. */
+	     it won't offer it.  */
 
 	  struct type *ftype = value_type (argvec[0]);
 
@@ -1867,8 +1869,8 @@ evaluate_subexp_standard (struct type *expect_type,
          array subscript operations cannot be disambiguated 
          at parse time.  We have made all array subscript operations, 
          substring operations as well as function calls  come here 
-         and we now have to discover what the heck this thing actually was.  
-         If it is a function, we process just as if we got an OP_FUNCALL. */
+         and we now have to discover what the heck this thing actually was.
+         If it is a function, we process just as if we got an OP_FUNCALL.  */
 
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 2;
@@ -1915,9 +1917,9 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	case TYPE_CODE_PTR:
 	case TYPE_CODE_FUNC:
-	  /* It's a function call. */
+	  /* It's a function call.  */
 	  /* Allocate arg vector, including space for the function to be
-	     called in argvec[0] and a terminating NULL */
+	     called in argvec[0] and a terminating NULL.  */
 	  argvec = (struct value **)
 	    alloca (sizeof (struct value *) * (nargs + 2));
 	  argvec[0] = arg1;
@@ -1933,7 +1935,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
     case OP_COMPLEX:
       /* We have a complex number, There should be 2 floating 
-         point numbers that compose it */
+         point numbers that compose it.  */
       (*pos) += 2;
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
@@ -1989,7 +1991,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
       /* JYG: if print object is on we need to replace the base type
 	 with rtti type in order to continue on with successful
-	 lookup of member / method only available in the rtti type. */
+	 lookup of member / method only available in the rtti type.  */
       {
         struct type *type = value_type (arg1);
         struct type *real_type;
@@ -2248,7 +2250,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	{
 	  /* If the user attempts to subscript something that is not an
 	     array or pointer type (like a plain int variable for example),
-	     then report this as an error. */
+	     then report this as an error.  */
 
 	  arg1 = coerce_ref (arg1);
 	  type = check_typedef (value_type (arg1));
@@ -2283,7 +2285,7 @@ evaluate_subexp_standard (struct type *expect_type,
       while (nargs-- > 0)
 	{
 	  arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
-	  /* FIXME:  EVAL_SKIP handling may not be correct. */
+	  /* FIXME:  EVAL_SKIP handling may not be correct.  */
 	  if (noside == EVAL_SKIP)
 	    {
 	      if (nargs > 0)
@@ -2295,12 +2297,12 @@ evaluate_subexp_standard (struct type *expect_type,
 		  goto nosideret;
 		}
 	    }
-	  /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
+	  /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct.  */
 	  if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	    {
 	      /* If the user attempts to subscript something that has no target
 	         type (like a plain int variable for example), then report this
-	         as an error. */
+	         as an error.  */
 
 	      type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
 	      if (type != NULL)
@@ -2356,7 +2358,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	int array_size_array[MAX_FORTRAN_DIMS];
 	int ndimensions = 1, i;
 	struct type *tmp_type;
-	int offset_item;	/* The array offset where the item lives */
+	int offset_item;	/* The array offset where the item lives.  */
 
 	if (nargs > MAX_FORTRAN_DIMS)
 	  error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
@@ -2370,21 +2372,21 @@ evaluate_subexp_standard (struct type *expect_type,
 	gdb_assert (nargs > 0);
 
 	/* Now that we know we have a legal array subscript expression 
-	   let us actually find out where this element exists in the array. */
+	   let us actually find out where this element exists in the array.  */
 
 	offset_item = 0;
-	/* Take array indices left to right */
+	/* Take array indices left to right.  */
 	for (i = 0; i < nargs; i++)
 	  {
-	    /* Evaluate each subscript, It must be a legal integer in F77 */
+	    /* Evaluate each subscript; it must be a legal integer in F77.  */
 	    arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 
-	    /* Fill in the subscript and array size arrays */
+	    /* Fill in the subscript and array size arrays.  */
 
 	    subscript_array[i] = value_as_long (arg2);
 	  }
 
-	/* Internal type of array is arranged right to left */
+	/* Internal type of array is arranged right to left.  */
 	for (i = 0; i < nargs; i++)
 	  {
 	    upper = f77_get_upperbound (tmp_type);
@@ -2392,23 +2394,23 @@ evaluate_subexp_standard (struct type *expect_type,
 
 	    array_size_array[nargs - i - 1] = upper - lower + 1;
 
-	    /* Zero-normalize subscripts so that offsetting will work. */
+	    /* Zero-normalize subscripts so that offsetting will work.  */
 
 	    subscript_array[nargs - i - 1] -= lower;
 
 	    /* If we are at the bottom of a multidimensional 
 	       array type then keep a ptr to the last ARRAY
 	       type around for use when calling value_subscript()
-	       below. This is done because we pretend to value_subscript
+	       below.  This is done because we pretend to value_subscript
 	       that we actually have a one-dimensional array 
 	       of base element type that we apply a simple 
-	       offset to. */
+	       offset to.  */
 
 	    if (i < nargs - 1)
 	      tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
 	  }
 
-	/* Now let us calculate the offset for this item */
+	/* Now let us calculate the offset for this item.  */
 
 	offset_item = subscript_array[ndimensions - 1];
 
@@ -2421,7 +2423,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	   of the multidimensional array-set and pretend
 	   that it is actually a array of the final element 
 	   type, this will ensure that value_subscript()
-	   returns the correct type value */
+	   returns the correct type value.  */
 
 	deprecated_set_value_type (arg1, tmp_type);
 	return value_subscripted_rvalue (arg1, offset_item, 0);
@@ -2967,7 +2969,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
       var = exp->elts[pc + 2].symbol;
 
       /* C++: The "address" of a reference should yield the address
-       * of the object pointed to. Let value_addr() deal with it. */
+       * of the object pointed to.  Let value_addr() deal with it.  */
       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
 	goto default_case;
 
@@ -3030,9 +3032,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
    Note that we currently only do the coercion for C expressions, where
    arrays are zero based and the coercion is correct.  For other languages,
    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION
-   to decide if coercion is appropriate.
-
- */
+   to decide if coercion is appropriate.  */
 
 struct value *
 evaluate_subexp_with_coercion (struct expression *exp,
@@ -3120,7 +3120,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
     }
 }
 
-/* Parse a type expression in the string [P..P+LENGTH). */
+/* Parse a type expression in the string [P..P+LENGTH).  */
 
 struct type *
 parse_and_eval_type (char *p, int length)