import gdb-1999-07-07 post reformat

1 files changed, 146 insertions, 142 deletions

diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index fa19797..71d8efd 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -16,8 +16,9 @@
 
    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.
-*/
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+ */
 
 /* by Steve Chamberlain, sac@cygnus.com */
 
@@ -84,16 +85,18 @@ static int last_sig = 0;	/* Set if a signal was received from the
 /* Thread information structure used to track information that is
    not available in gdb's thread structure. */
 typedef struct thread_info_struct
-{
-  struct thread_info_struct *next;
-  DWORD id;
-  HANDLE h;
-  char *name;
-  int suspend_count;
-  CONTEXT context;
-} thread_info;
+  {
+    struct thread_info_struct *next;
+    DWORD id;
+    HANDLE h;
+    char *name;
+    int suspend_count;
+    CONTEXT context;
+  }
+thread_info;
 
-static thread_info thread_head = {NULL};
+static thread_info thread_head =
+{NULL};
 
 /* The process and thread handles for the above context. */
 
@@ -101,7 +104,7 @@ static DEBUG_EVENT current_event;	/* The current debug event from
 					   WaitForDebugEvent */
 static HANDLE current_process_handle;	/* Currently executing process */
 static thread_info *current_thread;	/* Info on currently selected thread */
-static DWORD main_thread_id;		/* Thread ID of the main thread */
+static DWORD main_thread_id;	/* Thread ID of the main thread */
 
 /* Counts of things. */
 static int exception_count = 0;
@@ -110,9 +113,9 @@ static int event_count = 0;
 /* User options. */
 static int new_console = 0;
 static int new_group = 0;
-static int debug_exec = 0;		/* show execution */
-static int debug_events = 0;		/* show events from kernel */
-static int debug_memory = 0;		/* show target memory accesses */
+static int debug_exec = 0;	/* show execution */
+static int debug_events = 0;	/* show events from kernel */
+static int debug_memory = 0;	/* show target memory accesses */
 static int debug_exceptions = 0;	/* show target exceptions */
 
 /* This vector maps GDB's idea of a register's number into an address
@@ -131,30 +134,30 @@ static int debug_exceptions = 0;	/* show target exceptions */
 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
 static const int mappings[] =
 {
-  context_offset(Eax),
-  context_offset(Ecx),
-  context_offset(Edx),
-  context_offset(Ebx),
-  context_offset(Esp),
-  context_offset(Ebp),
-  context_offset(Esi),
-  context_offset(Edi),
-  context_offset(Eip),
-  context_offset(EFlags),
-  context_offset(SegCs),
-  context_offset(SegSs),
-  context_offset(SegDs),
-  context_offset(SegEs),
-  context_offset(SegFs),
-  context_offset(SegGs),
-  context_offset(FloatSave.RegisterArea[0 * 10]),
-  context_offset(FloatSave.RegisterArea[1 * 10]),
-  context_offset(FloatSave.RegisterArea[2 * 10]),
-  context_offset(FloatSave.RegisterArea[3 * 10]),
-  context_offset(FloatSave.RegisterArea[4 * 10]),
-  context_offset(FloatSave.RegisterArea[5 * 10]),
-  context_offset(FloatSave.RegisterArea[6 * 10]),
-  context_offset(FloatSave.RegisterArea[7 * 10]),
+  context_offset (Eax),
+  context_offset (Ecx),
+  context_offset (Edx),
+  context_offset (Ebx),
+  context_offset (Esp),
+  context_offset (Ebp),
+  context_offset (Esi),
+  context_offset (Edi),
+  context_offset (Eip),
+  context_offset (EFlags),
+  context_offset (SegCs),
+  context_offset (SegSs),
+  context_offset (SegDs),
+  context_offset (SegEs),
+  context_offset (SegFs),
+  context_offset (SegGs),
+  context_offset (FloatSave.RegisterArea[0 * 10]),
+  context_offset (FloatSave.RegisterArea[1 * 10]),
+  context_offset (FloatSave.RegisterArea[2 * 10]),
+  context_offset (FloatSave.RegisterArea[3 * 10]),
+  context_offset (FloatSave.RegisterArea[4 * 10]),
+  context_offset (FloatSave.RegisterArea[5 * 10]),
+  context_offset (FloatSave.RegisterArea[6 * 10]),
+  context_offset (FloatSave.RegisterArea[7 * 10]),
 };
 
 /* This vector maps the target's idea of an exception (extracted
@@ -184,7 +187,7 @@ thread_rec (DWORD id, int get_context)
 {
   thread_info *th;
 
-  for (th = &thread_head; (th = th->next) != NULL; )
+  for (th = &thread_head; (th = th->next) != NULL;)
     if (th->id == id)
       {
 	if (!th->suspend_count && get_context)
@@ -205,7 +208,7 @@ thread_rec (DWORD id, int get_context)
 
 /* Add a thread to the thread list */
 static thread_info *
-child_add_thread(DWORD id, HANDLE h)
+child_add_thread (DWORD id, HANDLE h)
 {
   thread_info *th;
 
@@ -213,7 +216,7 @@ child_add_thread(DWORD id, HANDLE h)
     return th;
 
   th = (thread_info *) xmalloc (sizeof (*th));
-  memset(th, 0, sizeof (*th));
+  memset (th, 0, sizeof (*th));
   th->id = id;
   th->h = h;
   th->next = thread_head.next;
@@ -316,7 +319,7 @@ child_store_inferior_registers (int r)
 static int
 handle_load_dll (PTR dummy)
 {
-  LOAD_DLL_DEBUG_INFO * event = &current_event.u.LoadDll;
+  LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
   DWORD dll_name_ptr;
   DWORD done;
   char dll_buf[MAX_PATH + 1];
@@ -324,7 +327,7 @@ handle_load_dll (PTR dummy)
   struct objfile *objfile;
   MEMORY_BASIC_INFORMATION minfo;
 
-  dll_buf[0] = dll_buf[sizeof(dll_buf) - 1] = '\0';
+  dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 
   /* The following code attempts to find the name of the dll by reading the
      name from the processes memory.  Unfortunately it doesn't work right.
@@ -332,7 +335,8 @@ handle_load_dll (PTR dummy)
 #ifdef DOESNT_WORK
   memset (&minfo, 0, sizeof minfo);
   if (VirtualQueryEx (current_process_handle, (LPCVOID) event->lpBaseOfDll,
-		      &minfo, sizeof(minfo)) && minfo.BaseAddress) {
+		      &minfo, sizeof (minfo)) && minfo.BaseAddress)
+    {
       DWORD len;
       IMAGE_DOS_HEADER *hmm0 = (IMAGE_DOS_HEADER *) minfo.BaseAddress;
       HMODULE hmm = (HMODULE) (((DWORD) hmm0) + hmm0->e_lfanew);
@@ -342,7 +346,7 @@ handle_load_dll (PTR dummy)
 	  dll_name = dll_buf;
 	  dll_name[len] = '\0';
 	}
-  }
+    }
 #endif
 
   /* Attempt to read the name of the dll that was detected.
@@ -360,7 +364,7 @@ handle_load_dll (PTR dummy)
 			 sizeof (dll_name_ptr), &done);
 
       /* See if we could read the address of a string, and that the
-	 address isn't null. */
+         address isn't null. */
 
       if (done != sizeof (dll_name_ptr) || !dll_name_ptr)
 	return 1;
@@ -410,23 +414,23 @@ handle_load_dll (PTR dummy)
   /* FIXME!! It would be nice to define one symbol which pointed to the
      front of the dll if we can't find any symbols. */
 
-  if (!(dll_basename = strrchr(dll_name, '/')))
+  if (!(dll_basename = strrchr (dll_name, '/')))
     dll_basename = dll_name;
   else
     dll_basename++;
 
-  ALL_OBJFILES(objfile)
-    {
-      char *objfile_basename;
-      objfile_basename = strrchr(objfile->name, '/');
+  ALL_OBJFILES (objfile)
+  {
+    char *objfile_basename;
+    objfile_basename = strrchr (objfile->name, '/');
 
-      if (objfile_basename &&
-	  strcmp(dll_basename, objfile_basename + 1) == 0)
-	{
-	  printf_unfiltered ("%x:%s (symbols previously loaded)\n",
-			     event->lpBaseOfDll, dll_name);
-	  goto out;
-	}
+    if (objfile_basename &&
+	strcmp (dll_basename, objfile_basename + 1) == 0)
+      {
+	printf_unfiltered ("%x:%s (symbols previously loaded)\n",
+			   event->lpBaseOfDll, dll_name);
+	goto out;
+      }
   }
 
   /* The symbols in a dll are offset by 0x1000, which is the
@@ -453,18 +457,18 @@ handle_output_debug_string (struct target_waitstatus *ourstatus)
   int gotasig = FALSE;
 
   if (!target_read_string
-      ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
+    ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
       || !s || !*s)
     return gotasig;
 
-  if (strncmp(s, CYGWIN_SIGNAL_STRING, sizeof(CYGWIN_SIGNAL_STRING) - 1))
+  if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1))
     {
       warning (s);
     }
   else
     {
       char *p;
-      /*last_sig = */strtol(s + sizeof(CYGWIN_SIGNAL_STRING) - 1, &p, 0);
+      /*last_sig = */ strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
       gotasig = target_signal_from_host (last_sig);
       ourstatus->value.sig = gotasig;
       if (gotasig)
@@ -491,41 +495,41 @@ handle_exception (struct target_waitstatus *ourstatus)
     {
     case EXCEPTION_ACCESS_VIOLATION:
       DEBUG_EXCEPT (("gdb: Target exception ACCESS_VIOLATION at 0x%08x\n",
-		     current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+	       current_event.u.Exception.ExceptionRecord.ExceptionAddress));
       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
       break;
     case STATUS_STACK_OVERFLOW:
       DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
-		     current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+	       current_event.u.Exception.ExceptionRecord.ExceptionAddress));
       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
       break;
     case EXCEPTION_BREAKPOINT:
       DEBUG_EXCEPT (("gdb: Target exception BREAKPOINT at 0x%08x\n",
-		     current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+	       current_event.u.Exception.ExceptionRecord.ExceptionAddress));
       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
       break;
     case DBG_CONTROL_C:
       DEBUG_EXCEPT (("gdb: Target exception CONTROL_C at 0x%08x\n",
-		     current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+	       current_event.u.Exception.ExceptionRecord.ExceptionAddress));
       ourstatus->value.sig = TARGET_SIGNAL_INT;
       /* User typed CTRL-C.  Continue with this status */
       last_sig = SIGINT;	/* FIXME - should check pass state */
       break;
     case EXCEPTION_SINGLE_STEP:
       DEBUG_EXCEPT (("gdb: Target exception SINGLE_STEP at 0x%08x\n",
-		     current_event.u.Exception.ExceptionRecord.ExceptionAddress));
+	       current_event.u.Exception.ExceptionRecord.ExceptionAddress));
       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
       break;
     default:
       /* This may be a structured exception handling exception.  In
-	 that case, we want to let the program try to handle it, and
-	 only break if we see the exception a second time.  */
+         that case, we want to let the program try to handle it, and
+         only break if we see the exception a second time.  */
       if (current_event.u.Exception.dwFirstChance)
 	return 0;
 
       printf_unfiltered ("gdb: unknown target exception 0x%08x at 0x%08x\n",
-			 current_event.u.Exception.ExceptionRecord.ExceptionCode,
-			 current_event.u.Exception.ExceptionRecord.ExceptionAddress);
+		    current_event.u.Exception.ExceptionRecord.ExceptionCode,
+		current_event.u.Exception.ExceptionRecord.ExceptionAddress);
       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
       break;
     }
@@ -548,7 +552,7 @@ child_continue (DWORD continue_status, int id)
 			    current_event.dwThreadId,
 			    continue_status);
   if (res)
-    for (th = &thread_head; (th = th->next) != NULL; )
+    for (th = &thread_head; (th = th->next) != NULL;)
       if (((id == -1) || (id == th->id)) && th->suspend_count)
 	{
 	  for (i = 0; i < th->suspend_count; i++)
@@ -586,38 +590,38 @@ child_wait (int pid, struct target_waitstatus *ourstatus)
 	    {
 	    case CREATE_THREAD_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "CREATE_THREAD_DEBUG_EVENT"));
 	      /* Record the existence of this thread */
 	      child_add_thread (current_event.dwThreadId,
 				current_event.u.CreateThread.hThread);
 	      if (info_verbose)
 		printf_unfiltered ("[New %s]\n",
-				   target_pid_to_str (current_event.dwThreadId));
+			      target_pid_to_str (current_event.dwThreadId));
 	      break;
 
 	    case EXIT_THREAD_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "EXIT_THREAD_DEBUG_EVENT"));
 	      child_delete_thread (current_event.dwThreadId);
 	      break;
 
 	    case CREATE_PROCESS_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "CREATE_PROCESS_DEBUG_EVENT"));
 	      current_process_handle = current_event.u.CreateProcessInfo.hProcess;
 
 	      main_thread_id = inferior_pid = current_event.dwThreadId;
 	      /* Add the main thread */
 	      current_thread = child_add_thread (inferior_pid,
-						 current_event.u.CreateProcessInfo.hThread);
+				 current_event.u.CreateProcessInfo.hThread);
 	      break;
 
 	    case EXIT_PROCESS_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "EXIT_PROCESS_DEBUG_EVENT"));
 	      ourstatus->kind = TARGET_WAITKIND_EXITED;
 	      ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
@@ -627,30 +631,30 @@ child_wait (int pid, struct target_waitstatus *ourstatus)
 
 	    case LOAD_DLL_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "LOAD_DLL_DEBUG_EVENT"));
 	      catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL);
-	      registers_changed();          /* mark all regs invalid */
+	      registers_changed ();	/* mark all regs invalid */
 	      break;
 
 	    case UNLOAD_DLL_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "UNLOAD_DLL_DEBUG_EVENT"));
-	      break;	/* FIXME: don't know what to do here */
+	      break;		/* FIXME: don't know what to do here */
 
 	    case EXCEPTION_DEBUG_EVENT:
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "EXCEPTION_DEBUG_EVENT"));
 	      if (handle_exception (ourstatus))
 		return current_event.dwThreadId;
 	      continue_status = DBG_EXCEPTION_NOT_HANDLED;
 	      break;
 
-	    case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
+	    case OUTPUT_DEBUG_STRING_EVENT:	/* message from the kernel */
 	      DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-			     current_event.dwProcessId, current_event.dwThreadId,
+			current_event.dwProcessId, current_event.dwThreadId,
 			     "OUTPUT_DEBUG_STRING_EVENT"));
 	      if (handle_output_debug_string (ourstatus))
 		return main_thread_id;
@@ -769,7 +773,7 @@ child_create_inferior (exec_file, allargs, env)
   char real_path[MAXPATHLEN];
   char *winenv;
   char *temp;
-  int  envlen;
+  int envlen;
   int i;
 
   STARTUPINFO si;
@@ -815,10 +819,10 @@ child_create_inferior (exec_file, allargs, env)
        to posix style if necessary.  */
 
     static const char *conv_path_names[] =
-      {
-	"PATH=",
-	0
-      };
+    {
+      "PATH=",
+      0
+    };
 
     /* CreateProcess takes the environment list as a null terminated set of
        strings (i.e. two nulls terminate the list).  */
@@ -878,7 +882,7 @@ child_create_inferior (exec_file, allargs, env)
   }
 
   ret = CreateProcess (0,
-		       args, 	/* command line */
+		       args,	/* command line */
 		       NULL,	/* Security */
 		       NULL,	/* thread */
 		       TRUE,	/* inherit handles */
@@ -888,7 +892,7 @@ child_create_inferior (exec_file, allargs, env)
 		       &si,
 		       &pi);
   if (!ret)
-    error ("Error creating process %s, (error %d)\n", exec_file, GetLastError());
+    error ("Error creating process %s, (error %d)\n", exec_file, GetLastError ());
 
   exception_count = 0;
   event_count = 0;
@@ -926,7 +930,7 @@ child_stop ()
 {
   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0));
-  registers_changed();		/* refresh register state */
+  registers_changed ();		/* refresh register state */
 }
 
 int
@@ -971,7 +975,7 @@ child_kill_inferior (void)
 
   /* this may fail in an attached process so don't check. */
   (void) CloseHandle (current_thread->h);
-  target_mourn_inferior();	/* or just child_mourn_inferior? */
+  target_mourn_inferior ();	/* or just child_mourn_inferior? */
 }
 
 void
@@ -980,7 +984,7 @@ child_resume (int pid, int step, enum target_signal sig)
   int i;
   thread_info *th;
   DWORD continue_status = last_sig > 0 && last_sig < NSIG ?
-			  DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
+  DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
 
   DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
 	       pid, step, sig));
@@ -1029,58 +1033,58 @@ child_close ()
   DEBUG_EVENTS (("gdb: child_close, inferior_pid=%d\n", inferior_pid));
 }
 
-struct target_ops child_ops ;
+struct target_ops child_ops;
 
-static void 
-init_child_ops(void)
+static void
+init_child_ops (void)
 {
-  child_ops.to_shortname =   "child";
-  child_ops.to_longname =   "Win32 child process";
-  child_ops.to_doc =   "Win32 child process (started by the \"run\" command).";
-  child_ops.to_open =   child_open;
-  child_ops.to_close =   child_close;
-  child_ops.to_attach =   child_attach;
-  child_ops.to_detach =   child_detach;
-  child_ops.to_resume =   child_resume;
-  child_ops.to_wait  =   child_wait;
-  child_ops.to_fetch_registers  =   child_fetch_inferior_registers;
-  child_ops.to_store_registers  =   child_store_inferior_registers;
-  child_ops.to_prepare_to_store =   child_prepare_to_store;
-  child_ops.to_xfer_memory  =   child_xfer_memory;
-  child_ops.to_files_info  =   child_files_info;
-  child_ops.to_insert_breakpoint =   memory_insert_breakpoint;
-  child_ops.to_remove_breakpoint =   memory_remove_breakpoint;
-  child_ops.to_terminal_init  =   terminal_init_inferior;
-  child_ops.to_terminal_inferior =   terminal_inferior;
-  child_ops.to_terminal_ours_for_output =   terminal_ours_for_output;
-  child_ops.to_terminal_ours  =   terminal_ours;
-  child_ops.to_terminal_info  =   child_terminal_info;
-  child_ops.to_kill  =   child_kill_inferior;
-  child_ops.to_load  =   0;
-  child_ops.to_lookup_symbol =   0;
-  child_ops.to_create_inferior =   child_create_inferior;
-  child_ops.to_mourn_inferior =   child_mourn_inferior;
-  child_ops.to_can_run  =   child_can_run;
-  child_ops.to_notice_signals =   0;
-  child_ops.to_thread_alive  =   win32_child_thread_alive;
-  child_ops.to_stop  =   child_stop;
-  child_ops.to_stratum =   process_stratum;
-  child_ops.DONT_USE =   0;
-  child_ops.to_has_all_memory =   1;
-  child_ops.to_has_memory =   1;
-  child_ops.to_has_stack =   1;
-  child_ops.to_has_registers =   1;
-  child_ops.to_has_execution =   1;
-  child_ops.to_sections =   0;
-  child_ops.to_sections_end =   0;
-  child_ops.to_magic =   OPS_MAGIC;
+  child_ops.to_shortname = "child";
+  child_ops.to_longname = "Win32 child process";
+  child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
+  child_ops.to_open = child_open;
+  child_ops.to_close = child_close;
+  child_ops.to_attach = child_attach;
+  child_ops.to_detach = child_detach;
+  child_ops.to_resume = child_resume;
+  child_ops.to_wait = child_wait;
+  child_ops.to_fetch_registers = child_fetch_inferior_registers;
+  child_ops.to_store_registers = child_store_inferior_registers;
+  child_ops.to_prepare_to_store = child_prepare_to_store;
+  child_ops.to_xfer_memory = child_xfer_memory;
+  child_ops.to_files_info = child_files_info;
+  child_ops.to_insert_breakpoint = memory_insert_breakpoint;
+  child_ops.to_remove_breakpoint = memory_remove_breakpoint;
+  child_ops.to_terminal_init = terminal_init_inferior;
+  child_ops.to_terminal_inferior = terminal_inferior;
+  child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
+  child_ops.to_terminal_ours = terminal_ours;
+  child_ops.to_terminal_info = child_terminal_info;
+  child_ops.to_kill = child_kill_inferior;
+  child_ops.to_load = 0;
+  child_ops.to_lookup_symbol = 0;
+  child_ops.to_create_inferior = child_create_inferior;
+  child_ops.to_mourn_inferior = child_mourn_inferior;
+  child_ops.to_can_run = child_can_run;
+  child_ops.to_notice_signals = 0;
+  child_ops.to_thread_alive = win32_child_thread_alive;
+  child_ops.to_stop = child_stop;
+  child_ops.to_stratum = process_stratum;
+  child_ops.DONT_USE = 0;
+  child_ops.to_has_all_memory = 1;
+  child_ops.to_has_memory = 1;
+  child_ops.to_has_stack = 1;
+  child_ops.to_has_registers = 1;
+  child_ops.to_has_execution = 1;
+  child_ops.to_sections = 0;
+  child_ops.to_sections_end = 0;
+  child_ops.to_magic = OPS_MAGIC;
 }
 
 void
 _initialize_inftarg ()
 {
   struct cmd_list_element *c;
-  init_child_ops() ;
+  init_child_ops ();
 
   add_show_from_set
     (add_set_cmd ("new-console", class_support, var_boolean,
@@ -1120,7 +1124,7 @@ _initialize_inftarg ()
   add_show_from_set
     (add_set_cmd ("debugexceptions", class_support, var_boolean,
 		  (char *) &debug_exceptions,
-		  "Set whether to display kernel exceptions in child process.",
+	       "Set whether to display kernel exceptions in child process.",
 		  &setlist),
      &showlist);
 
@@ -1133,8 +1137,8 @@ _initialize_inftarg ()
 static int
 win32_child_thread_alive (int pid)
 {
-  return WaitForSingleObject(thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
-	 FALSE : TRUE;
+  return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
+    FALSE : TRUE;
 }
 
 /* Convert pid to printable format. */