import gdb-1999-07-07 post reformat

1 files changed, 182 insertions, 179 deletions

diff --git a/gdb/inftarg.c b/gdb/inftarg.c
index d615ff9cffa..96fb3d92da1 100644
--- a/gdb/inftarg.c
+++ b/gdb/inftarg.c
@@ -2,26 +2,27 @@
    Copyright 1990-1996, 1998, 1999 Free Software Foundation, Inc.
    Contributed by Cygnus Support.
 
-## Contains temporary hacks..
+   ## Contains temporary hacks..
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
-#include "frame.h"  /* required by inferior.h */
+#include "frame.h"		/* required by inferior.h */
 #include "inferior.h"
 #include "target.h"
 #include "gdbcore.h"
@@ -32,11 +33,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include <fcntl.h>
 
 #ifdef HAVE_WAIT_H
-# include <wait.h>
+#include <wait.h>
 #else
-# ifdef HAVE_SYS_WAIT_H
-#  include <sys/wait.h>
-# endif
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
 #endif
 
 /* "wait.h" fills in the gaps left by <wait.h> */
@@ -46,10 +47,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #endif
 
 extern struct symtab_and_line *
-child_enable_exception_callback PARAMS ((enum exception_event_kind, int));
+  child_enable_exception_callback PARAMS ((enum exception_event_kind, int));
 
 extern struct exception_event_record *
-child_get_current_exception_event PARAMS ((void));
+  child_get_current_exception_event PARAMS ((void));
 
 extern void _initialize_inftarg PARAMS ((void));
 
@@ -95,10 +96,10 @@ child_require_detach PARAMS ((int, char *, int));
 static void
 ptrace_me PARAMS ((void));
 
-static void 
+static void
 ptrace_him PARAMS ((int));
 
-static void 
+static void
 child_create_inferior PARAMS ((char *, char *, char **));
 
 static void
@@ -127,14 +128,14 @@ int child_suppress_run = 0;	/* Non-zero if inftarg should pretend not to
 
 #ifndef CHILD_WAIT
 
-/*##*/
+/*## */
 /* Enable HACK for ttrace work.  In
  * infttrace.c/require_notification_of_events,
  * this is set to 0 so that the loop in child_wait
  * won't loop.
  */
 int not_same_real_pid = 1;
-/*##*/
+/*## */
 
 
 /* Wait for child to do something.  Return pid of child, or -1 in case
@@ -148,101 +149,103 @@ child_wait (pid, ourstatus)
   int save_errno;
   int status;
   char *execd_pathname = NULL;
-  int  exit_status;
-  int  related_pid;
-  int  syscall_id;
-  enum target_waitkind  kind;
+  int exit_status;
+  int related_pid;
+  int syscall_id;
+  enum target_waitkind kind;
 
-  do {
-    set_sigint_trap();	/* Causes SIGINT to be passed on to the
-			   attached process. */
-    set_sigio_trap ();
+  do
+    {
+      set_sigint_trap ();	/* Causes SIGINT to be passed on to the
+				   attached process. */
+      set_sigio_trap ();
 
-    pid = ptrace_wait (inferior_pid, &status);
+      pid = ptrace_wait (inferior_pid, &status);
 
-    save_errno = errno;
+      save_errno = errno;
 
-    clear_sigio_trap ();
+      clear_sigio_trap ();
 
-    clear_sigint_trap();
+      clear_sigint_trap ();
 
-    if (pid == -1)
-      {
-	if (save_errno == EINTR)
-	  continue;
+      if (pid == -1)
+	{
+	  if (save_errno == EINTR)
+	    continue;
 
-	fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing: %s.\n",
-		 safe_strerror (save_errno));
+	  fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing: %s.\n",
+			      safe_strerror (save_errno));
 
-	/* Claim it exited with unknown signal.  */
-	ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
-	ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
-        return -1;
-      }
+	  /* Claim it exited with unknown signal.  */
+	  ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+	  ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
+	  return -1;
+	}
 
-    /* Did it exit?
-     */
-    if (target_has_exited (pid, status, &exit_status))
-      {
-        /* ??rehrauer: For now, ignore this. */
-        continue;
-      }
-
-    if (!target_thread_alive (pid))
-      {
-        ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
-        return pid;
-      }
-      
-    if (target_has_forked (pid, &related_pid)
-	 && ((pid == inferior_pid) || (related_pid == inferior_pid)))
-      {
-        ourstatus->kind = TARGET_WAITKIND_FORKED;
-        ourstatus->value.related_pid = related_pid;
-        return pid;
-      }
-
-    if (target_has_vforked (pid, &related_pid)
-	 && ((pid == inferior_pid) || (related_pid == inferior_pid)))
-      {
-        ourstatus->kind = TARGET_WAITKIND_VFORKED;
-        ourstatus->value.related_pid = related_pid;
-        return pid;
-      }
-
-    if (target_has_execd (pid, &execd_pathname))
-      {
-        /* Are we ignoring initial exec events?  (This is likely because
-           we're in the process of starting up the inferior, and another
-           (older) mechanism handles those.)  If so, we'll report this
-           as a regular stop, not an exec.
-           */
-        if (inferior_ignoring_startup_exec_events)
-          {
-            inferior_ignoring_startup_exec_events--;
-          }
-        else
-          {
-            ourstatus->kind = TARGET_WAITKIND_EXECD;
-            ourstatus->value.execd_pathname = execd_pathname;
-            return pid;
-          }
-      }
-
-    /* All we must do with these is communicate their occurrence
-       to wait_for_inferior...
+      /* Did it exit?
        */
-    if (target_has_syscall_event (pid, &kind, &syscall_id))
-      {
-        ourstatus->kind = kind;
-        ourstatus->value.syscall_id = syscall_id;
-        return pid;
-      }
-
-/*##  } while (pid != inferior_pid); ##*/ /* Some other child died or stopped */
+      if (target_has_exited (pid, status, &exit_status))
+	{
+	  /* ??rehrauer: For now, ignore this. */
+	  continue;
+	}
+
+      if (!target_thread_alive (pid))
+	{
+	  ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+	  return pid;
+	}
+
+      if (target_has_forked (pid, &related_pid)
+	  && ((pid == inferior_pid) || (related_pid == inferior_pid)))
+	{
+	  ourstatus->kind = TARGET_WAITKIND_FORKED;
+	  ourstatus->value.related_pid = related_pid;
+	  return pid;
+	}
+
+      if (target_has_vforked (pid, &related_pid)
+	  && ((pid == inferior_pid) || (related_pid == inferior_pid)))
+	{
+	  ourstatus->kind = TARGET_WAITKIND_VFORKED;
+	  ourstatus->value.related_pid = related_pid;
+	  return pid;
+	}
+
+      if (target_has_execd (pid, &execd_pathname))
+	{
+	  /* Are we ignoring initial exec events?  (This is likely because
+	     we're in the process of starting up the inferior, and another
+	     (older) mechanism handles those.)  If so, we'll report this
+	     as a regular stop, not an exec.
+	   */
+	  if (inferior_ignoring_startup_exec_events)
+	    {
+	      inferior_ignoring_startup_exec_events--;
+	    }
+	  else
+	    {
+	      ourstatus->kind = TARGET_WAITKIND_EXECD;
+	      ourstatus->value.execd_pathname = execd_pathname;
+	      return pid;
+	    }
+	}
+
+      /* All we must do with these is communicate their occurrence
+         to wait_for_inferior...
+       */
+      if (target_has_syscall_event (pid, &kind, &syscall_id))
+	{
+	  ourstatus->kind = kind;
+	  ourstatus->value.syscall_id = syscall_id;
+	  return pid;
+	}
+
+      /*##  } while (pid != inferior_pid); ## *//* Some other child died or stopped */
 /* hack for thread testing */
-      } while( (pid != inferior_pid) && not_same_real_pid );
-/*##*/
+    }
+  while ((pid != inferior_pid) && not_same_real_pid);
+/*## */
 
   store_waitstatus (ourstatus, status);
   return pid;
@@ -252,15 +255,15 @@ child_wait (pid, ourstatus)
 #if !defined(CHILD_POST_WAIT)
 void
 child_post_wait (pid, wait_status)
-  int  pid;
-  int  wait_status;
+     int pid;
+     int wait_status;
 {
   /* This version of Unix doesn't require a meaningful "post wait"
      operation.
-     */
+   */
 }
 #endif
- 
+
 
 #ifndef CHILD_THREAD_ALIVE
 
@@ -280,9 +283,9 @@ child_thread_alive (pid)
 
 static void
 child_attach_to_process (args, from_tty, after_fork)
-  char *  args;
-  int  from_tty;
-  int  after_fork;
+     char *args;
+     int from_tty;
+     int after_fork;
 {
   if (!args)
     error_no_arg ("process-id to attach");
@@ -301,7 +304,7 @@ child_attach_to_process (args, from_tty, after_fork)
     if ((pid == 0) && (args == dummy))
       error ("Illegal process-id: %s\n", args);
 
-    if (pid == getpid())		/* Trying to masturbate? */
+    if (pid == getpid ())	/* Trying to masturbate? */
       error ("I refuse to debug myself!");
 
     if (from_tty)
@@ -309,13 +312,13 @@ child_attach_to_process (args, from_tty, after_fork)
 	exec_file = (char *) get_exec_file (0);
 
 	if (after_fork)
-	  printf_unfiltered ("Attaching after fork to %s\n", 
-		  target_pid_to_str (pid));
+	  printf_unfiltered ("Attaching after fork to %s\n",
+			     target_pid_to_str (pid));
 	else if (exec_file)
 	  printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
-                  target_pid_to_str (pid));
-        else
-          printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
+			     target_pid_to_str (pid));
+	else
+	  printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
 
 	gdb_flush (gdb_stdout);
       }
@@ -328,7 +331,7 @@ child_attach_to_process (args, from_tty, after_fork)
     inferior_pid = pid;
     push_target (&child_ops);
   }
-#endif  /* ATTACH_DETACH */
+#endif /* ATTACH_DETACH */
 }
 
 
@@ -345,7 +348,7 @@ child_attach (args, from_tty)
 #if !defined(CHILD_POST_ATTACH)
 void
 child_post_attach (pid)
-  int  pid;
+     int pid;
 {
   /* This version of Unix doesn't require a meaningful "post attach"
      operation by a debugger.  */
@@ -358,14 +361,14 @@ child_require_attach (args, from_tty)
      int from_tty;
 {
   child_attach_to_process (args, from_tty, 1);
-} 
+}
 
 static void
 child_detach_from_process (pid, args, from_tty, after_fork)
-  int  pid;
-  char *  args;
-  int  from_tty;
-  int  after_fork;
+     int pid;
+     char *args;
+     int from_tty;
+     int after_fork;
 {
 #ifdef ATTACH_DETACH
   {
@@ -376,12 +379,12 @@ child_detach_from_process (pid, args, from_tty, after_fork)
 	char *exec_file = get_exec_file (0);
 	if (exec_file == 0)
 	  exec_file = "";
-        if (after_fork)
-          printf_unfiltered ("Detaching after fork from %s\n",
-                             target_pid_to_str (pid));
-        else
+	if (after_fork)
+	  printf_unfiltered ("Detaching after fork from %s\n",
+			     target_pid_to_str (pid));
+	else
 	  printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
-		             target_pid_to_str (pid));
+			     target_pid_to_str (pid));
 	gdb_flush (gdb_stdout);
       }
     if (args)
@@ -417,9 +420,9 @@ child_detach (args, from_tty)
 
 static void
 child_require_detach (pid, args, from_tty)
-  int  pid;
-  char *  args;
-  int  from_tty;
+     int pid;
+     char *args;
+     int from_tty;
 {
   child_detach_from_process (pid, args, from_tty, 1);
 }
@@ -446,7 +449,7 @@ child_files_info (ignore)
      struct target_ops *ignore;
 {
   printf_unfiltered ("\tUsing the running image of %s %s.\n",
-	  attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
+      attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
 }
 
 /* ARGSUSED */
@@ -471,7 +474,7 @@ ptrace_me ()
 /* Stub function which causes the GDB that runs it, to start ptrace-ing
    the child process.  */
 
-static void 
+static void
 ptrace_him (pid)
      int pid;
 {
@@ -481,7 +484,7 @@ ptrace_him (pid)
      between the parent and child processes after the debugger
      forks, and before the child execs the debuggee program.  This
      call basically gives permission for the child to exec.
-     */
+   */
 
   target_acknowledge_created_inferior (pid);
 
@@ -493,7 +496,7 @@ ptrace_him (pid)
 
   /* On some targets, there must be some explicit actions taken after
      the inferior has been started up.
-     */
+   */
   target_post_startup_inferior (pid);
 }
 
@@ -511,46 +514,46 @@ child_create_inferior (exec_file, allargs, env)
 #ifdef HPUXHPPA
   fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, pre_fork_inferior, NULL);
 #else
- fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, NULL, NULL);
+  fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, NULL, NULL);
 #endif
   /* We are at the first instruction we care about.  */
   /* Pedal to the metal... */
-  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
+  proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
 }
 
 #if !defined(CHILD_POST_STARTUP_INFERIOR)
 void
 child_post_startup_inferior (pid)
-  int  pid;
+     int pid;
 {
   /* This version of Unix doesn't require a meaningful "post startup inferior"
      operation by a debugger.
-     */
+   */
 }
 #endif
 
 #if !defined(CHILD_ACKNOWLEDGE_CREATED_INFERIOR)
 void
 child_acknowledge_created_inferior (pid)
-  int  pid;
+     int pid;
 {
   /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
      operation by a debugger.
-     */
+   */
 }
 #endif
 
 
 void
 child_clone_and_follow_inferior (child_pid, followed_child)
-  int  child_pid;
-  int  *followed_child;
+     int child_pid;
+     int *followed_child;
 {
   clone_and_follow_inferior (child_pid, followed_child);
 
   /* Don't resume CHILD_PID; it's stopped where it ought to be, until
      the decision gets made elsewhere how to continue it.
-     */
+   */
 }
 
 
@@ -560,7 +563,7 @@ child_post_follow_inferior_by_clone ()
 {
   /* This version of Unix doesn't require a meaningful "post follow inferior"
      operation by a clone debugger.
-     */
+   */
 }
 #endif
 
@@ -619,11 +622,11 @@ child_has_forked (pid, child_pid)
 #if !defined(CHILD_HAS_VFORKED)
 int
 child_has_vforked (pid, child_pid)
-  int  pid;
-  int *  child_pid;
+     int pid;
+     int *child_pid;
 {
   /* This version of Unix doesn't support notification of vfork events.
-     */
+   */
   return 0;
 }
 #endif
@@ -636,7 +639,7 @@ child_can_follow_vfork_prior_to_exec ()
   /* This version of Unix doesn't support notification of vfork events.
      However, if it did, it probably wouldn't allow vforks to be followed
      before the following exec.
-     */
+   */
   return 0;
 }
 #endif
@@ -645,14 +648,14 @@ child_can_follow_vfork_prior_to_exec ()
 #if !defined(CHILD_POST_FOLLOW_VFORK)
 void
 child_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
-  int  parent_pid;
-  int  followed_parent;
-  int  child_pid;
-  int  followed_child;
+     int parent_pid;
+     int followed_parent;
+     int child_pid;
+     int followed_child;
 {
   /* This version of Unix doesn't require a meaningful "post follow vfork"
      operation by a clone debugger.
-     */
+   */
 }
 #endif
 
@@ -679,11 +682,11 @@ child_remove_exec_catchpoint (pid)
 #if !defined(CHILD_HAS_EXECD)
 int
 child_has_execd (pid, execd_pathname)
-  int  pid;
-  char **  execd_pathname;
+     int pid;
+     char **execd_pathname;
 {
   /* This version of Unix doesn't support notification of exec events.
-     */
+   */
   return 0;
 }
 #endif
@@ -694,7 +697,7 @@ int
 child_reported_exec_events_per_exec_call ()
 {
   /* This version of Unix doesn't support notification of exec events.
-     */
+   */
   return 1;
 }
 #endif
@@ -703,12 +706,12 @@ child_reported_exec_events_per_exec_call ()
 #if !defined(CHILD_HAS_SYSCALL_EVENT)
 int
 child_has_syscall_event (pid, kind, syscall_id)
-  int  pid;
-  enum target_waitkind *  kind;
-  int *  syscall_id;
+     int pid;
+     enum target_waitkind *kind;
+     int *syscall_id;
 {
   /* This version of Unix doesn't support notification of syscall events.
-     */
+   */
   return 0;
 }
 #endif
@@ -717,9 +720,9 @@ child_has_syscall_event (pid, kind, syscall_id)
 #if !defined(CHILD_HAS_EXITED)
 int
 child_has_exited (pid, wait_status, exit_status)
-  int  pid;
-  int  wait_status;
-  int *  exit_status;
+     int pid;
+     int wait_status;
+     int *exit_status;
 {
   if (WIFEXITED (wait_status))
     {
@@ -729,12 +732,12 @@ child_has_exited (pid, wait_status, exit_status)
 
   if (WIFSIGNALED (wait_status))
     {
-      *exit_status = 0;  /* ?? Don't know what else to say here. */
+      *exit_status = 0;		/* ?? Don't know what else to say here. */
       return 1;
     }
 
   /* ?? Do we really need to consult the event state, too?  Assume the
-   wait_state alone suffices.
+     wait_state alone suffices.
    */
   return 0;
 }
@@ -775,8 +778,8 @@ child_stop ()
 #if !defined(CHILD_ENABLE_EXCEPTION_CALLBACK)
 struct symtab_and_line *
 child_enable_exception_callback (kind, enable)
-  enum exception_event_kind kind;
-  int enable;
+     enum exception_event_kind kind;
+     int enable;
 {
   return (struct symtab_and_line *) NULL;
 }
@@ -794,27 +797,27 @@ child_get_current_exception_event ()
 #if !defined(CHILD_PID_TO_EXEC_FILE)
 char *
 child_pid_to_exec_file (pid)
-  int  pid;
+     int pid;
 {
   /* This version of Unix doesn't support translation of a process ID
      to the filename of the executable file.
-     */
+   */
   return NULL;
 }
 #endif
 
 char *
 child_core_file_to_sym_file (core)
-  char *  core;
+     char *core;
 {
   /* The target stratum for a running executable need not support
      this operation.
-     */
+   */
   return NULL;
 }
+
 
 
-
 static void
 init_child_ops ()
 {