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

	* s390-tdep.c: Comment cleanup, mostly periods and spaces.
	* score-tdep.c: Ditto.
	* score-tdep.h: Ditto.
	* ser-base.c: Ditto.
	* ser-go32.c: Ditto.
	* serial.c: Ditto.
	* serial.h: Ditto.
	* ser-mingw.c: Ditto.
	* ser-pipe.c: Ditto.
	* ser-tcp.c: Ditto.
	* ser-unix.c: Ditto.
	* sh64-tdep.c: Ditto.
	* shnbsd-nat.c: Ditto.
	* sh-tdep.c: Ditto.
	* sh-tdep.h: Ditto.
	* solib.c: Ditto.
	* solib-darwin.c: Ditto.
	* solib-frv.c: Ditto.
	* solib.h: Ditto.
	* solib-irix.c: Ditto.
	* solib-osf.c: Ditto.
	* solib-pa64.c: Ditto.
	* solib-som.c: Ditto.
	* solib-spu.c: Ditto.
	* solib-sunos.c: Ditto.
	* solib-svr4.c: Ditto.
	* solist.h: Ditto.
	* sol-thread.c: Ditto.
	* somread.c: Ditto.
	* source.c: Ditto.
	* source.h: Ditto.
	* sparc64-linux-tdep.c: Ditto.
	* sparc64-tdep.c: Ditto.
	* sparc-linux-nat.c: Ditto.
	* sparc-linux-tdep.c: Ditto.
	* sparc-sol2-nat.c: Ditto.
	* sparc-sol2-tdep.c: Ditto.
	* sparc-tdep.c: Ditto.
	* sparc-tdep.h: Ditto.
	* spu-tdep.c: Ditto.
	* stabsread.c: Ditto.
	* stabsread.h: Ditto.
	* stack.c: Ditto.
	* symfile.c: Ditto.
	* symfile.h: Ditto.
	* symmisc.c: Ditto.
	* symtab.c: Ditto.
	* symtab.h: Ditto.
	* target.c: Ditto.
	* target-descriptions.c: Ditto.
	* target-descriptions.h: Ditto.
	* target.h: Ditto.
	* target-memory.c: Ditto.
	* terminal.h: Ditto.
	* thread.c: Ditto.
	* top.c: Ditto.
	* tracepoint.c: Ditto.
	* tracepoint.h: Ditto.
	* trad-frame.h: Ditto.
	* typeprint.c: Ditto.

1 files changed, 28 insertions, 28 deletions

diff --git a/gdb/target.c b/gdb/target.c
index 4854834..ff87931 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -500,7 +500,7 @@ void
 target_terminal_inferior (void)
 {
   /* A background resume (``run&'') should leave GDB in control of the
-     terminal. Use target_can_async_p, not target_is_async_p, since at
+     terminal.  Use target_can_async_p, not target_is_async_p, since at
      this point the target is not async yet.  However, if sync_execution
      is not set, we know it will become async prior to resume.  */
   if (target_can_async_p () && !sync_execution)
@@ -515,8 +515,8 @@ static int
 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 	  struct target_ops *t)
 {
-  errno = EIO;			/* Can't read/write this location */
-  return 0;			/* No bytes handled */
+  errno = EIO;			/* Can't read/write this location.  */
+  return 0;			/* No bytes handled.  */
 }
 
 static void
@@ -535,7 +535,7 @@ noprocess (void)
 static int
 nosymbol (char *name, CORE_ADDR *addrp)
 {
-  return 1;			/* Symbol does not exist in target env */
+  return 1;			/* Symbol does not exist in target env.  */
 }
 
 static void
@@ -646,11 +646,11 @@ update_current_target (void)
       INHERIT (to_pid_to_exec_file, t);
       INHERIT (to_log_command, t);
       INHERIT (to_stratum, t);
-      /* Do not inherit to_has_all_memory */
-      /* Do not inherit to_has_memory */
-      /* Do not inherit to_has_stack */
-      /* Do not inherit to_has_registers */
-      /* Do not inherit to_has_execution */
+      /* Do not inherit to_has_all_memory.  */
+      /* Do not inherit to_has_memory.  */
+      /* Do not inherit to_has_stack.  */
+      /* Do not inherit to_has_registers.  */
+      /* Do not inherit to_has_execution.  */
       INHERIT (to_has_thread_control, t);
       INHERIT (to_can_async_p, t);
       INHERIT (to_is_async_p, t);
@@ -968,7 +968,7 @@ unpush_target (struct target_ops *t)
 		    _("Attempt to unpush the dummy target"));
 
   /* Look for the specified target.  Note that we assume that a target
-     can only occur once in the target stack. */
+     can only occur once in the target stack.  */
 
   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
     {
@@ -977,7 +977,7 @@ unpush_target (struct target_ops *t)
     }
 
   if ((*cur) == NULL)
-    return 0;			/* Didn't find target_ops, quit now */
+    return 0;			/* Didn't find target_ops, quit now.  */
 
   /* NOTE: cagney/2003-12-06: In '94 the close call was made
      unconditional by moving it to before the above check that the
@@ -987,7 +987,7 @@ unpush_target (struct target_ops *t)
      targets should be closed.  */
   target_close (t, 0);
 
-  /* Unchain the target */
+  /* Unchain the target.  */
   tmp = (*cur);
   (*cur) = (*cur)->beneath;
   tmp->beneath = NULL;
@@ -1000,7 +1000,7 @@ unpush_target (struct target_ops *t)
 void
 pop_target (void)
 {
-  target_close (target_stack, 0);	/* Let it clean up */
+  target_close (target_stack, 0);	/* Let it clean up.  */
   if (unpush_target (target_stack) == 1)
     return;
 
@@ -1195,7 +1195,7 @@ target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
       if (errcode != 0)
 	{
 	  /* The transfer request might have crossed the boundary to an
-	     unallocated region of memory. Retry the transfer, requesting
+	     unallocated region of memory.  Retry the transfer, requesting
 	     a single byte.  */
 	  tlen = 1;
 	  offset = 0;
@@ -1543,7 +1543,7 @@ target_xfer_partial (struct target_ops *ops,
    filling the buffer with good data.  There is no way for the caller to know
    how much good data might have been transfered anyway.  Callers that can
    deal with partial reads should call target_read (which will retry until
-   it makes no progress, and then return how much was transferred). */
+   it makes no progress, and then return how much was transferred).  */
 
 int
 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
@@ -1799,17 +1799,17 @@ target_read (struct target_ops *ops,
 
     The function results, in RESULT, either zero or one memory block.
     If there's a readable subrange at the beginning, it is completely
-    read and returned. Any further readable subrange will not be read.
+    read and returned.  Any further readable subrange will not be read.
     Otherwise, if there's a readable subrange at the end, it will be
     completely read and returned.  Any readable subranges before it (obviously,
-    not starting at the beginning), will be ignored. In other cases --
+    not starting at the beginning), will be ignored.  In other cases --
     either no readable subrange, or readable subrange (s) that is neither
     at the beginning, or end, nothing is returned.
 
     The purpose of this function is to handle a read across a boundary of
-    accessible memory in a case when memory map is not available. The above
+    accessible memory in a case when memory map is not available.  The above
     restrictions are fine for this case, but will give incorrect results if
-    the memory is 'patchy'. However, supporting 'patchy' memory would require
+    the memory is 'patchy'.  However, supporting 'patchy' memory would require
     trying to read every single byte, and it seems unacceptable solution.
     Explicit memory map is recommended for this case -- and
     target_read_memory_robust will take care of reading multiple ranges
@@ -1831,7 +1831,7 @@ read_whatever_is_readable (struct target_ops *ops,
     return;
 
   /* Check that either first or the last byte is readable, and give up
-     if not. This heuristic is meant to permit reading accessible memory
+     if not.  This heuristic is meant to permit reading accessible memory
      at the boundary of accessible region.  */
   if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
 			   buf, begin, 1) == 1)
@@ -1884,15 +1884,15 @@ read_whatever_is_readable (struct target_ops *ops,
 
       if (xfer == first_half_end - first_half_begin)
 	{
-	  /* This half reads up fine. So, the error must be in the
+	  /* This half reads up fine.  So, the error must be in the
 	     other half.  */
 	  current_begin = second_half_begin;
 	  current_end = second_half_end;
 	}
       else
 	{
-	  /* This half is not readable. Because we've tried one byte, we
-	     know some part of this half if actually redable. Go to the next
+	  /* This half is not readable.  Because we've tried one byte, we
+	     know some part of this half if actually redable.  Go to the next
 	     iteration to divide again and try to read.
 
 	     We don't handle the other half, because this function only tries
@@ -1957,7 +1957,7 @@ read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
 
       if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
 	{
-	  /* Cannot read this region. Note that we can end up here only
+	  /* Cannot read this region.  Note that we can end up here only
 	     if the region is explicitly marked inaccessible, or
 	     'inaccessible-by-default' is in effect.  */
 	  xfered += rlen;
@@ -1973,7 +1973,7 @@ read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
 	  /* Call an observer, notifying them of the xfer progress?  */
 	  if (xfer <= 0)
 	    {
-	      /* Got an error reading full chunk. See if maybe we can read
+	      /* Got an error reading full chunk.  See if maybe we can read
 		 some subrange.  */
 	      xfree (buffer);
 	      read_whatever_is_readable (ops, offset + xfered,
@@ -2233,9 +2233,9 @@ target_info (char *args, int from_tty)
 void
 target_pre_inferior (int from_tty)
 {
-  /* Clear out solib state. Otherwise the solib state of the previous
+  /* Clear out solib state.  Otherwise the solib state of the previous
      inferior might have survived and is entirely wrong for the new
-     target.  This has been observed on GNU/Linux using glibc 2.3. How
+     target.  This has been observed on GNU/Linux using glibc 2.3.  How
      to reproduce:
 
      bash$ ./foo&
@@ -2699,7 +2699,7 @@ target_require_runnable (void)
 
   /* This function is only called if the target is running.  In that
      case there should have been a process_stratum target and it
-     should either know how to create inferiors, or not... */
+     should either know how to create inferiors, or not...  */
   internal_error (__FILE__, __LINE__, _("No targets found"));
 }