[deliverable/binutils-gdb.git] / gdb / mac-nat.c

/* Target-vector operations for controlling Mac applications, for GDB.
   Copyright 1995, 1996, 1998, 1999, 2000, 2001
   Free Software Foundation, Inc.
   Written by Stan Shebs.  Contributed by Cygnus Support.

   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 distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without eve nthe 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.  */

/* Note that because all the available Mac compilers are ANSI or very
   close, and this is a native-only file, the code may be purely ANSI.  */

#include "defs.h"
#include "frame.h"		/* required by inferior.h */
#include "inferior.h"
#include "target.h"
#include "gdb_wait.h"
#include "gdbcore.h"
#include "command.h"
#include <signal.h>
#include <sys/types.h>
#include <fcntl.h>
#include "buildsym.h"
#include "gdb_string.h"
#include "gdbthread.h"
#include "gdbcmd.h"
#include "regcache.h"

#include <Processes.h>

/* We call the functions "child_..." rather than "mac_..." so no one
   is tempted to try to link this with other native-only code.  */

/* Forward declaration */

extern struct target_ops child_ops;

static void child_stop (void);

static void
child_fetch_inferior_registers (int r)
{
  if (r < 0)
    {
      for (r = 0; r < NUM_REGS; r++)
	child_fetch_inferior_registers (r);
    }
  else
    {
      supply_register (r, 0);
    }
}

static void
child_store_inferior_registers (int r)
{
  if (r < 0)
    {
      for (r = 0; r < NUM_REGS; r++)
	child_store_inferior_registers (r);
    }
  else
    {
      read_register_gen (r, 0);
    }
}

static int
child_wait (int pid, struct target_waitstatus *ourstatus)
{
}

/* Attach to process PID, then initialize for debugging it.  */

static void
child_attach (char *args, int from_tty)
{
  ProcessSerialNumber psn;
  ProcessInfoRec inforec;
  Str31 name;
  FSSpecPtr fsspec;
  OSType code;
  int pid;
  char *exec_file;

  if (!args)
    error_no_arg ("process-id to attach");

  pid = atoi (args);

  psn.highLongOfPSN = 0;
  psn.lowLongOfPSN = pid;

  inforec.processInfoLength = sizeof (ProcessInfoRec);
  inforec.processName = name;
  inforec.processAppSpec = fsspec;

  if (GetProcessInformation (&psn, &inforec) == noErr)
    {
      if (from_tty)
	{
	  exec_file = (char *) get_exec_file (0);

	  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));

	  gdb_flush (gdb_stdout);
	}
      /* Do we need to do anything special? */
      attach_flag = 1;
      inferior_pid = pid;
      push_target (&child_ops);
    }
}

static void
child_detach (char *args, int from_tty)
{
  char *exec_file;

  if (from_tty)
    {
      exec_file = get_exec_file (0);
      if (exec_file == 0)
	exec_file = "";
      printf_unfiltered ("Detaching from program: %s %s\n", exec_file,
			 target_pid_to_str (inferior_pid));
      gdb_flush (gdb_stdout);
    }
  inferior_pid = 0;
  unpush_target (&child_ops);
}

/* Print status information about what we're accessing.  */

static void
child_files_info (struct target_ops *ignore)
{
  printf_unfiltered ("\tUsing the running image of %s %s.\n",
      attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
}

/* ARGSUSED */
static void
child_open (char *arg, int from_tty)
{
  error ("Use the \"run\" command to start a Mac application.");
}

/* Start an inferior Mac program and sets inferior_pid to its pid.
   EXEC_FILE is the file to run.
   ALLARGS is a string containing the arguments to the program.
   ENV is the environment vector to pass.  Errors reported with error().  */

static void
child_create_inferior (char *exec_file, char *allargs, char **env)
{
  LaunchParamBlockRec launchparms;
  FSSpec fsspec;
  OSErr launch_err;

  if (!exec_file)
    {
      error ("No executable specified, use `target exec'.\n");
    }

  launchparms.launchBlockID = extendedBlock;
  launchparms.launchEPBLength = extendedBlockLen;
  launchparms.launchFileFlags = 0;
  launchparms.launchControlFlags = launchContinue | launchNoFileFlags;
  fsspec.vRefNum = 0;
  fsspec.parID = 0;
  strcpy (fsspec.name + 1, exec_file);
  fsspec.name[0] = strlen (exec_file);
  launchparms.launchAppSpec = &fsspec;
  launchparms.launchAppParameters = nil;

  launch_err = LaunchApplication (&launchparms);

  if (launch_err == 999 /*memFullErr */ )
    {
      error ("Not enough memory to launch %s\n", exec_file);
    }
  else if (launch_err != noErr)
    {
      error ("Error launching %s, code %d\n", exec_file, launch_err);
    }

  inferior_pid = launchparms.launchProcessSN.lowLongOfPSN;
  /* FIXME be sure that high long of PSN is 0 */

  push_target (&child_ops);
  init_wait_for_inferior ();
  clear_proceed_status ();

/*  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);  */
}

static void
child_mourn_inferior (void)
{
  unpush_target (&child_ops);
  generic_mourn_inferior ();
}

static void
child_stop (void)
{
}

int
child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
		   struct mem_attrib *attrib,
		   struct target_ops *target)
{
  int i;

  for (i = 0; i < len; ++i)
    {
      if (write)
	{
	  ((char *) memaddr)[i] = myaddr[i];
	}
      else
	{
	  myaddr[i] = ((char *) memaddr)[i];
	}
    }
  return len;
}

void
child_kill_inferior (void)
{
}

void
child_resume (int pid, int step, enum target_signal signal)
{
}

static void
child_prepare_to_store (void)
{
  /* Do nothing, since we can store individual regs */
}

static int
child_can_run (void)
{
  return 1;
}

static void
child_close (void)
{
}

static void
info_proc (char *args, int from_tty)
{
  ProcessSerialNumber psn;
  ProcessInfoRec inforec;
  Str31 name;
  FSSpecPtr fsspec;
  OSType code;

  /* Eventually use args, but not right now. */

  psn.highLongOfPSN = 0;
  psn.lowLongOfPSN = kNoProcess;

  inforec.processInfoLength = sizeof (ProcessInfoRec);
  inforec.processName = name;
  inforec.processAppSpec = fsspec;

  printf_filtered ("Process Name                     Sgnt Type    PSN   Loc Size FreeMem Time\n");

  while (GetNextProcess (&psn) == noErr)
    {
      if (GetProcessInformation (&psn, &inforec) == noErr)
	{
	  name[name[0] + 1] = '\0';
	  printf_filtered ("%-32.32s", name + 1);
	  code = inforec.processSignature;
	  printf_filtered (" %c%c%c%c",
			   (code >> 24) & 0xff,
			   (code >> 16) & 0xff,
			   (code >> 8) & 0xff,
			   (code >> 0) & 0xff);
	  code = inforec.processType;
	  printf_filtered (" %c%c%c%c",
			   (code >> 24) & 0xff,
			   (code >> 16) & 0xff,
			   (code >> 8) & 0xff,
			   (code >> 0) & 0xff);
	  if (psn.highLongOfPSN == 0)
	    printf_filtered (" %9d", psn.lowLongOfPSN);
	  else
	    printf_filtered (" %9d,%9d\n",
			     psn.highLongOfPSN, psn.lowLongOfPSN);
	  printf_filtered (" 0x%x", inforec.processLocation);
	  printf_filtered (" %9d", inforec.processSize);
	  printf_filtered (" %9d", inforec.processFreeMem);
	  printf_filtered (" %9d", inforec.processActiveTime);
	  printf_filtered ("\n");
	}
    }
}

struct target_ops child_ops;

static void
init_child_ops (void)
{
  child_ops.to_shortname = "mac";
  child_ops.to_longname = "MacOS application";
  child_ops.to_doc = "MacOS application (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_post_attach = NULL;
  child_ops.to_require_attach = NULL;	/* to_require_attach */
  child_ops.to_detach = child_detach;
  child_ops.to_require_detach = NULL;	/* to_require_detach */
  child_ops.to_resume = child_resume;
  child_ops.to_wait = child_wait;
  child_ops.to_post_wait = NULL;	/* to_post_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 = 0;
  child_ops.to_terminal_inferior = 0;
  child_ops.to_terminal_ours_for_output = 0;
  child_ops.to_terminal_ours = 0;
  child_ops.to_terminal_info = 0;
  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_post_startup_inferior = NULL;	/* to_post_startup_inferior */
  child_ops.to_acknowledge_created_inferior = NULL;	/* to_acknowledge_created_inferior */
  child_ops.to_clone_and_follow_inferior = NULL;	/* to_clone_and_follow_inferior */
  child_ops.to_post_follow_inferior_by_clone = NULL;	/* to_post_follow_inferior_by_clone */
  child_ops.to_insert_fork_catchpoint = NULL;
  child_ops.to_remove_fork_catchpoint = NULL;
  child_ops.to_insert_vfork_catchpoint = NULL;
  child_ops.to_remove_vfork_catchpoint = NULL;
  child_ops.to_has_forked = NULL;	/* to_has_forked */
  child_ops.to_has_vforked = NULL;	/* to_has_vforked */
  child_ops.to_can_follow_vfork_prior_to_exec = NULL;
  child_ops.to_post_follow_vfork = NULL;	/* to_post_follow_vfork */
  child_ops.to_insert_exec_catchpoint = NULL;
  child_ops.to_remove_exec_catchpoint = NULL;
  child_ops.to_has_execd = NULL;
  child_ops.to_reported_exec_events_per_exec_call = NULL;
  child_ops.to_has_exited = NULL;
  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 = 0;
  child_ops.to_stop = child_stop;
  child_ops.to_pid_to_exec_file = NULL;		/* to_pid_to_exec_file */
  child_ops.to_core_file_to_sym_file = NULL;
  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_mac_nat (void)
{
  init_child_ops ();

  add_info ("proc", info_proc,
	    "Show information about processes.");
}
Commit	Line	Data
c906108c	1	/* Target-vector operations for controlling Mac applications, for GDB.
b6ba6518 KB	2	Copyright 1995, 1996, 1998, 1999, 2000, 2001
b6ba6518 KB	3	Free Software Foundation, Inc.
c906108c SS	4	Written by Stan Shebs. Contributed by Cygnus Support.
c906108c SS	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
c906108c	12
c5aa993b JM	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
c906108c	17
c5aa993b JM	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
c906108c SS	22
	23	/* Note that because all the available Mac compilers are ANSI or very
	24	close, and this is a native-only file, the code may be purely ANSI. */
	25
	26	#include "defs.h"
	27	#include "frame.h" /* required by inferior.h */
	28	#include "inferior.h"
	29	#include "target.h"
03f2053f	30	#include "gdb_wait.h"
c906108c SS	31	#include "gdbcore.h"
	32	#include "command.h"
	33	#include <signal.h>
	34	#include <sys/types.h>
	35	#include <fcntl.h>
	36	#include "buildsym.h"
	37	#include "gdb_string.h"
	38	#include "gdbthread.h"
	39	#include "gdbcmd.h"
4e052eda	40	#include "regcache.h"
c906108c SS	41
	42	#include <Processes.h>
	43
	44	/* We call the functions "child_..." rather than "mac_..." so no one
	45	is tempted to try to link this with other native-only code. */
	46
	47	/* Forward declaration */
	48
	49	extern struct target_ops child_ops;
	50
a14ed312	51	static void child_stop (void);
c906108c SS	52
	53	static void
	54	child_fetch_inferior_registers (int r)
	55	{
	56	if (r < 0)
	57	{
	58	for (r = 0; r < NUM_REGS; r++)
	59	child_fetch_inferior_registers (r);
	60	}
	61	else
	62	{
	63	supply_register (r, 0);
	64	}
	65	}
	66
	67	static void
	68	child_store_inferior_registers (int r)
	69	{
	70	if (r < 0)
	71	{
	72	for (r = 0; r < NUM_REGS; r++)
	73	child_store_inferior_registers (r);
	74	}
	75	else
	76	{
	77	read_register_gen (r, 0);
	78	}
	79	}
	80
	81	static int
	82	child_wait (int pid, struct target_waitstatus *ourstatus)
	83	{
	84	}
	85
	86	/* Attach to process PID, then initialize for debugging it. */
	87
	88	static void
fba45db2	89	child_attach (char *args, int from_tty)
c906108c SS	90	{
	91	ProcessSerialNumber psn;
	92	ProcessInfoRec inforec;
	93	Str31 name;
	94	FSSpecPtr fsspec;
	95	OSType code;
	96	int pid;
	97	char *exec_file;
	98
	99	if (!args)
	100	error_no_arg ("process-id to attach");
	101
	102	pid = atoi (args);
	103
	104	psn.highLongOfPSN = 0;
	105	psn.lowLongOfPSN = pid;
	106
c5aa993b	107	inforec.processInfoLength = sizeof (ProcessInfoRec);
c906108c SS	108	inforec.processName = name;
	109	inforec.processAppSpec = fsspec;
	110
	111	if (GetProcessInformation (&psn, &inforec) == noErr)
	112	{
	113	if (from_tty)
	114	{
	115	exec_file = (char *) get_exec_file (0);
	116
	117	if (exec_file)
	118	printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
	119	target_pid_to_str (pid));
	120	else
	121	printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
	122
	123	gdb_flush (gdb_stdout);
	124	}
	125	/* Do we need to do anything special? */
	126	attach_flag = 1;
	127	inferior_pid = pid;
	128	push_target (&child_ops);
	129	}
	130	}
	131
	132	static void
fba45db2	133	child_detach (char *args, int from_tty)
c906108c SS	134	{
	135	char *exec_file;
	136
	137	if (from_tty)
	138	{
	139	exec_file = get_exec_file (0);
	140	if (exec_file == 0)
	141	exec_file = "";
	142	printf_unfiltered ("Detaching from program: %s %s\n", exec_file,
	143	target_pid_to_str (inferior_pid));
	144	gdb_flush (gdb_stdout);
	145	}
	146	inferior_pid = 0;
	147	unpush_target (&child_ops);
	148	}
	149
	150	/* Print status information about what we're accessing. */
	151
	152	static void
fba45db2	153	child_files_info (struct target_ops *ignore)
c906108c SS	154	{
	155	printf_unfiltered ("\tUsing the running image of %s %s.\n",
	156	attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
	157	}
	158
	159	/* ARGSUSED */
	160	static void
fba45db2	161	child_open (char *arg, int from_tty)
c906108c SS	162	{
	163	error ("Use the \"run\" command to start a Mac application.");
	164	}
	165
	166	/* Start an inferior Mac program and sets inferior_pid to its pid.
	167	EXEC_FILE is the file to run.
	168	ALLARGS is a string containing the arguments to the program.
	169	ENV is the environment vector to pass. Errors reported with error(). */
	170
	171	static void
fba45db2	172	child_create_inferior (char exec_file, char allargs, char **env)
c906108c SS	173	{
	174	LaunchParamBlockRec launchparms;
	175	FSSpec fsspec;
	176	OSErr launch_err;
	177
	178	if (!exec_file)
	179	{
	180	error ("No executable specified, use `target exec'.\n");
	181	}
	182
	183	launchparms.launchBlockID = extendedBlock;
	184	launchparms.launchEPBLength = extendedBlockLen;
	185	launchparms.launchFileFlags = 0;
	186	launchparms.launchControlFlags = launchContinue \| launchNoFileFlags;
	187	fsspec.vRefNum = 0;
	188	fsspec.parID = 0;
c5aa993b JM	189	strcpy (fsspec.name + 1, exec_file);
c5aa993b JM	190	fsspec.name[0] = strlen (exec_file);
c906108c SS	191	launchparms.launchAppSpec = &fsspec;
	192	launchparms.launchAppParameters = nil;
	193
	194	launch_err = LaunchApplication (&launchparms);
	195
c5aa993b	196	if (launch_err == 999 /memFullErr / )
c906108c SS	197	{
	198	error ("Not enough memory to launch %s\n", exec_file);
	199	}
	200	else if (launch_err != noErr)
	201	{
	202	error ("Error launching %s, code %d\n", exec_file, launch_err);
	203	}
	204
	205	inferior_pid = launchparms.launchProcessSN.lowLongOfPSN;
	206	/* FIXME be sure that high long of PSN is 0 */
	207
	208	push_target (&child_ops);
	209	init_wait_for_inferior ();
	210	clear_proceed_status ();
	211
2acceee2	212	/* proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); */
c906108c SS	213	}
	214
	215	static void
fba45db2	216	child_mourn_inferior (void)
c906108c SS	217	{
	218	unpush_target (&child_ops);
	219	generic_mourn_inferior ();
	220	}
	221
	222	static void
fba45db2	223	child_stop (void)
c906108c SS	224	{
	225	}
	226
	227	int
043780a1 AC	228	child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
	229	struct mem_attrib *attrib,
	230	struct target_ops *target)
c906108c SS	231	{
	232	int i;
	233
	234	for (i = 0; i < len; ++i)
	235	{
	236	if (write)
	237	{
	238	((char *) memaddr)[i] = myaddr[i];
	239	}
	240	else
	241	{
	242	myaddr[i] = ((char *) memaddr)[i];
	243	}
	244	}
	245	return len;
	246	}
	247
	248	void
	249	child_kill_inferior (void)
	250	{
	251	}
	252
	253	void
	254	child_resume (int pid, int step, enum target_signal signal)
	255	{
	256	}
	257
	258	static void
fba45db2	259	child_prepare_to_store (void)
c906108c SS	260	{
	261	/* Do nothing, since we can store individual regs */
	262	}
	263
	264	static int
fba45db2	265	child_can_run (void)
c906108c SS	266	{
	267	return 1;
	268	}
	269
	270	static void
fba45db2	271	child_close (void)
c906108c SS	272	{
	273	}
	274
	275	static void
fba45db2	276	info_proc (char *args, int from_tty)
c906108c SS	277	{
	278	ProcessSerialNumber psn;
	279	ProcessInfoRec inforec;
	280	Str31 name;
	281	FSSpecPtr fsspec;
	282	OSType code;
	283
	284	/* Eventually use args, but not right now. */
	285
	286	psn.highLongOfPSN = 0;
	287	psn.lowLongOfPSN = kNoProcess;
	288
c5aa993b	289	inforec.processInfoLength = sizeof (ProcessInfoRec);
c906108c SS	290	inforec.processName = name;
	291	inforec.processAppSpec = fsspec;
	292
	293	printf_filtered ("Process Name Sgnt Type PSN Loc Size FreeMem Time\n");
	294
	295	while (GetNextProcess (&psn) == noErr)
	296	{
	297	if (GetProcessInformation (&psn, &inforec) == noErr)
	298	{
	299	name[name[0] + 1] = '\0';
	300	printf_filtered ("%-32.32s", name + 1);
	301	code = inforec.processSignature;
	302	printf_filtered (" %c%c%c%c",
	303	(code >> 24) & 0xff,
	304	(code >> 16) & 0xff,
c5aa993b JM	305	(code >> 8) & 0xff,
c5aa993b JM	306	(code >> 0) & 0xff);
c906108c SS	307	code = inforec.processType;
	308	printf_filtered (" %c%c%c%c",
	309	(code >> 24) & 0xff,
	310	(code >> 16) & 0xff,
c5aa993b JM	311	(code >> 8) & 0xff,
c5aa993b JM	312	(code >> 0) & 0xff);
c906108c SS	313	if (psn.highLongOfPSN == 0)
	314	printf_filtered (" %9d", psn.lowLongOfPSN);
	315	else
	316	printf_filtered (" %9d,%9d\n",
	317	psn.highLongOfPSN, psn.lowLongOfPSN);
	318	printf_filtered (" 0x%x", inforec.processLocation);
	319	printf_filtered (" %9d", inforec.processSize);
	320	printf_filtered (" %9d", inforec.processFreeMem);
	321	printf_filtered (" %9d", inforec.processActiveTime);
	322	printf_filtered ("\n");
	323	}
	324	}
	325	}
	326
c5aa993b	327	struct target_ops child_ops;
c906108c	328
c5aa993b JM	329	static void
c5aa993b JM	330	init_child_ops (void)
c906108c	331	{
c5aa993b JM	332	child_ops.to_shortname = "mac";
	333	child_ops.to_longname = "MacOS application";
	334	child_ops.to_doc = "MacOS application (started by the \"run\" command).";
	335	child_ops.to_open = child_open;
	336	child_ops.to_close = child_close;
	337	child_ops.to_attach = child_attach;
c906108c	338	child_ops.to_post_attach = NULL;
c5aa993b JM	339	child_ops.to_require_attach = NULL; /* to_require_attach */
	340	child_ops.to_detach = child_detach;
	341	child_ops.to_require_detach = NULL; /* to_require_detach */
	342	child_ops.to_resume = child_resume;
	343	child_ops.to_wait = child_wait;
	344	child_ops.to_post_wait = NULL; /* to_post_wait */
	345	child_ops.to_fetch_registers = child_fetch_inferior_registers;
	346	child_ops.to_store_registers = child_store_inferior_registers;
	347	child_ops.to_prepare_to_store = child_prepare_to_store;
	348	child_ops.to_xfer_memory = child_xfer_memory;
	349	child_ops.to_files_info = child_files_info;
	350	child_ops.to_insert_breakpoint = memory_insert_breakpoint;
	351	child_ops.to_remove_breakpoint = memory_remove_breakpoint;
	352	child_ops.to_terminal_init = 0;
	353	child_ops.to_terminal_inferior = 0;
	354	child_ops.to_terminal_ours_for_output = 0;
	355	child_ops.to_terminal_ours = 0;
	356	child_ops.to_terminal_info = 0;
	357	child_ops.to_kill = child_kill_inferior;
	358	child_ops.to_load = 0;
	359	child_ops.to_lookup_symbol = 0;
c906108c	360	child_ops.to_create_inferior = child_create_inferior;
c5aa993b JM	361	child_ops.to_post_startup_inferior = NULL; /* to_post_startup_inferior */
	362	child_ops.to_acknowledge_created_inferior = NULL; /* to_acknowledge_created_inferior */
	363	child_ops.to_clone_and_follow_inferior = NULL; /* to_clone_and_follow_inferior */
	364	child_ops.to_post_follow_inferior_by_clone = NULL; /* to_post_follow_inferior_by_clone */
c906108c SS	365	child_ops.to_insert_fork_catchpoint = NULL;
	366	child_ops.to_remove_fork_catchpoint = NULL;
	367	child_ops.to_insert_vfork_catchpoint = NULL;
	368	child_ops.to_remove_vfork_catchpoint = NULL;
c5aa993b JM	369	child_ops.to_has_forked = NULL; /* to_has_forked */
c5aa993b JM	370	child_ops.to_has_vforked = NULL; /* to_has_vforked */
c906108c	371	child_ops.to_can_follow_vfork_prior_to_exec = NULL;
c5aa993b	372	child_ops.to_post_follow_vfork = NULL; /* to_post_follow_vfork */
c906108c SS	373	child_ops.to_insert_exec_catchpoint = NULL;
	374	child_ops.to_remove_exec_catchpoint = NULL;
	375	child_ops.to_has_execd = NULL;
	376	child_ops.to_reported_exec_events_per_exec_call = NULL;
	377	child_ops.to_has_exited = NULL;
c5aa993b JM	378	child_ops.to_mourn_inferior = child_mourn_inferior;
	379	child_ops.to_can_run = child_can_run;
	380	child_ops.to_notice_signals = 0;
	381	child_ops.to_thread_alive = 0;
	382	child_ops.to_stop = child_stop;
	383	child_ops.to_pid_to_exec_file = NULL; /* to_pid_to_exec_file */
c906108c	384	child_ops.to_core_file_to_sym_file = NULL;
c5aa993b JM	385	child_ops.to_stratum = process_stratum;
	386	child_ops.DONT_USE = 0;
	387	child_ops.to_has_all_memory = 1;
	388	child_ops.to_has_memory = 1;
	389	child_ops.to_has_stack = 1;
	390	child_ops.to_has_registers = 1;
	391	child_ops.to_has_execution = 1;
	392	child_ops.to_sections = 0;
	393	child_ops.to_sections_end = 0;
	394	child_ops.to_magic = OPS_MAGIC;
c906108c SS	395	};
	396
	397	void
fba45db2	398	_initialize_mac_nat (void)
c906108c	399	{
c5aa993b	400	init_child_ops ();
c906108c SS	401
	402	add_info ("proc", info_proc,
	403	"Show information about processes.");
	404	}