[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 ptid_t
child_wait (ptid_t ptid, 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_to_ptid (pid)));
	  else
	    printf_unfiltered ("Attaching to %s\n",
	                       target_pid_to_str (pid_to_ptid (pid)));

	  gdb_flush (gdb_stdout);
	}
      /* Do we need to do anything special? */
      attach_flag = 1;
      inferior_ptid = pid_to_ptid (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_ptid));
      gdb_flush (gdb_stdout);
    }
  inferior_ptid = null_ptid;
  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_ptid));
}

/* 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_ptid 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_ptid = pid_to_ptid (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 (ptid_t ptid, 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_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
39f77062 KB	81	static ptid_t
39f77062 KB	82	child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
c906108c SS	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,
39f77062	119	target_pid_to_str (pid_to_ptid (pid)));
c906108c	120	else
39f77062 KB	121	printf_unfiltered ("Attaching to %s\n",
39f77062 KB	122	target_pid_to_str (pid_to_ptid (pid)));
c906108c SS	123
	124	gdb_flush (gdb_stdout);
	125	}
	126	/* Do we need to do anything special? */
	127	attach_flag = 1;
39f77062	128	inferior_ptid = pid_to_ptid (pid);
c906108c SS	129	push_target (&child_ops);
	130	}
	131	}
	132
	133	static void
fba45db2	134	child_detach (char *args, int from_tty)
c906108c SS	135	{
	136	char *exec_file;
	137
	138	if (from_tty)
	139	{
	140	exec_file = get_exec_file (0);
	141	if (exec_file == 0)
	142	exec_file = "";
	143	printf_unfiltered ("Detaching from program: %s %s\n", exec_file,
39f77062	144	target_pid_to_str (inferior_ptid));
c906108c SS	145	gdb_flush (gdb_stdout);
c906108c SS	146	}
39f77062	147	inferior_ptid = null_ptid;
c906108c SS	148	unpush_target (&child_ops);
	149	}
	150
	151	/* Print status information about what we're accessing. */
	152
	153	static void
fba45db2	154	child_files_info (struct target_ops *ignore)
c906108c SS	155	{
c906108c SS	156	printf_unfiltered ("\tUsing the running image of %s %s.\n",
39f77062	157	attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
c906108c SS	158	}
	159
	160	/* ARGSUSED */
	161	static void
fba45db2	162	child_open (char *arg, int from_tty)
c906108c SS	163	{
	164	error ("Use the \"run\" command to start a Mac application.");
	165	}
	166
39f77062	167	/* Start an inferior Mac program and sets inferior_ptid to its pid.
c906108c SS	168	EXEC_FILE is the file to run.
	169	ALLARGS is a string containing the arguments to the program.
	170	ENV is the environment vector to pass. Errors reported with error(). */
	171
	172	static void
fba45db2	173	child_create_inferior (char exec_file, char allargs, char **env)
c906108c SS	174	{
	175	LaunchParamBlockRec launchparms;
	176	FSSpec fsspec;
	177	OSErr launch_err;
	178
	179	if (!exec_file)
	180	{
	181	error ("No executable specified, use `target exec'.\n");
	182	}
	183
	184	launchparms.launchBlockID = extendedBlock;
	185	launchparms.launchEPBLength = extendedBlockLen;
	186	launchparms.launchFileFlags = 0;
	187	launchparms.launchControlFlags = launchContinue \| launchNoFileFlags;
	188	fsspec.vRefNum = 0;
	189	fsspec.parID = 0;
c5aa993b JM	190	strcpy (fsspec.name + 1, exec_file);
c5aa993b JM	191	fsspec.name[0] = strlen (exec_file);
c906108c SS	192	launchparms.launchAppSpec = &fsspec;
	193	launchparms.launchAppParameters = nil;
	194
	195	launch_err = LaunchApplication (&launchparms);
	196
c5aa993b	197	if (launch_err == 999 /memFullErr / )
c906108c SS	198	{
	199	error ("Not enough memory to launch %s\n", exec_file);
	200	}
	201	else if (launch_err != noErr)
	202	{
	203	error ("Error launching %s, code %d\n", exec_file, launch_err);
	204	}
	205
39f77062	206	inferior_ptid = pid_to_ptid (launchparms.launchProcessSN.lowLongOfPSN);
c906108c SS	207	/* FIXME be sure that high long of PSN is 0 */
	208
	209	push_target (&child_ops);
	210	init_wait_for_inferior ();
	211	clear_proceed_status ();
	212
2acceee2	213	/* proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); */
c906108c SS	214	}
	215
	216	static void
fba45db2	217	child_mourn_inferior (void)
c906108c SS	218	{
	219	unpush_target (&child_ops);
	220	generic_mourn_inferior ();
	221	}
	222
	223	static void
fba45db2	224	child_stop (void)
c906108c SS	225	{
	226	}
	227
	228	int
043780a1 AC	229	child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
	230	struct mem_attrib *attrib,
	231	struct target_ops *target)
c906108c SS	232	{
	233	int i;
	234
	235	for (i = 0; i < len; ++i)
	236	{
	237	if (write)
	238	{
	239	((char *) memaddr)[i] = myaddr[i];
	240	}
	241	else
	242	{
	243	myaddr[i] = ((char *) memaddr)[i];
	244	}
	245	}
	246	return len;
	247	}
	248
	249	void
	250	child_kill_inferior (void)
	251	{
	252	}
	253
	254	void
39f77062	255	child_resume (ptid_t ptid, int step, enum target_signal signal)
c906108c SS	256	{
	257	}
	258
	259	static void
fba45db2	260	child_prepare_to_store (void)
c906108c SS	261	{
	262	/* Do nothing, since we can store individual regs */
	263	}
	264
	265	static int
fba45db2	266	child_can_run (void)
c906108c SS	267	{
	268	return 1;
	269	}
	270
	271	static void
fba45db2	272	child_close (void)
c906108c SS	273	{
	274	}
	275
	276	static void
fba45db2	277	info_proc (char *args, int from_tty)
c906108c SS	278	{
	279	ProcessSerialNumber psn;
	280	ProcessInfoRec inforec;
	281	Str31 name;
	282	FSSpecPtr fsspec;
	283	OSType code;
	284
	285	/* Eventually use args, but not right now. */
	286
	287	psn.highLongOfPSN = 0;
	288	psn.lowLongOfPSN = kNoProcess;
	289
c5aa993b	290	inforec.processInfoLength = sizeof (ProcessInfoRec);
c906108c SS	291	inforec.processName = name;
	292	inforec.processAppSpec = fsspec;
	293
	294	printf_filtered ("Process Name Sgnt Type PSN Loc Size FreeMem Time\n");
	295
	296	while (GetNextProcess (&psn) == noErr)
	297	{
	298	if (GetProcessInformation (&psn, &inforec) == noErr)
	299	{
	300	name[name[0] + 1] = '\0';
	301	printf_filtered ("%-32.32s", name + 1);
	302	code = inforec.processSignature;
	303	printf_filtered (" %c%c%c%c",
	304	(code >> 24) & 0xff,
	305	(code >> 16) & 0xff,
c5aa993b JM	306	(code >> 8) & 0xff,
c5aa993b JM	307	(code >> 0) & 0xff);
c906108c SS	308	code = inforec.processType;
	309	printf_filtered (" %c%c%c%c",
	310	(code >> 24) & 0xff,
	311	(code >> 16) & 0xff,
c5aa993b JM	312	(code >> 8) & 0xff,
c5aa993b JM	313	(code >> 0) & 0xff);
c906108c SS	314	if (psn.highLongOfPSN == 0)
	315	printf_filtered (" %9d", psn.lowLongOfPSN);
	316	else
	317	printf_filtered (" %9d,%9d\n",
	318	psn.highLongOfPSN, psn.lowLongOfPSN);
	319	printf_filtered (" 0x%x", inforec.processLocation);
	320	printf_filtered (" %9d", inforec.processSize);
	321	printf_filtered (" %9d", inforec.processFreeMem);
	322	printf_filtered (" %9d", inforec.processActiveTime);
	323	printf_filtered ("\n");
	324	}
	325	}
	326	}
	327
c5aa993b	328	struct target_ops child_ops;
c906108c	329
c5aa993b JM	330	static void
c5aa993b JM	331	init_child_ops (void)
c906108c	332	{
c5aa993b JM	333	child_ops.to_shortname = "mac";
	334	child_ops.to_longname = "MacOS application";
	335	child_ops.to_doc = "MacOS application (started by the \"run\" command).";
	336	child_ops.to_open = child_open;
	337	child_ops.to_close = child_close;
	338	child_ops.to_attach = child_attach;
c906108c	339	child_ops.to_post_attach = NULL;
c5aa993b JM	340	child_ops.to_require_attach = NULL; /* to_require_attach */
	341	child_ops.to_detach = child_detach;
	342	child_ops.to_require_detach = NULL; /* to_require_detach */
	343	child_ops.to_resume = child_resume;
	344	child_ops.to_wait = child_wait;
	345	child_ops.to_post_wait = NULL; /* to_post_wait */
	346	child_ops.to_fetch_registers = child_fetch_inferior_registers;
	347	child_ops.to_store_registers = child_store_inferior_registers;
	348	child_ops.to_prepare_to_store = child_prepare_to_store;
	349	child_ops.to_xfer_memory = child_xfer_memory;
	350	child_ops.to_files_info = child_files_info;
	351	child_ops.to_insert_breakpoint = memory_insert_breakpoint;
	352	child_ops.to_remove_breakpoint = memory_remove_breakpoint;
	353	child_ops.to_terminal_init = 0;
	354	child_ops.to_terminal_inferior = 0;
	355	child_ops.to_terminal_ours_for_output = 0;
	356	child_ops.to_terminal_ours = 0;
	357	child_ops.to_terminal_info = 0;
	358	child_ops.to_kill = child_kill_inferior;
	359	child_ops.to_load = 0;
	360	child_ops.to_lookup_symbol = 0;
c906108c	361	child_ops.to_create_inferior = child_create_inferior;
c5aa993b JM	362	child_ops.to_post_startup_inferior = NULL; /* to_post_startup_inferior */
	363	child_ops.to_acknowledge_created_inferior = NULL; /* to_acknowledge_created_inferior */
	364	child_ops.to_clone_and_follow_inferior = NULL; /* to_clone_and_follow_inferior */
	365	child_ops.to_post_follow_inferior_by_clone = NULL; /* to_post_follow_inferior_by_clone */
c906108c SS	366	child_ops.to_insert_fork_catchpoint = NULL;
	367	child_ops.to_remove_fork_catchpoint = NULL;
	368	child_ops.to_insert_vfork_catchpoint = NULL;
	369	child_ops.to_remove_vfork_catchpoint = NULL;
c5aa993b JM	370	child_ops.to_has_forked = NULL; /* to_has_forked */
c5aa993b JM	371	child_ops.to_has_vforked = NULL; /* to_has_vforked */
c906108c	372	child_ops.to_can_follow_vfork_prior_to_exec = NULL;
c5aa993b	373	child_ops.to_post_follow_vfork = NULL; /* to_post_follow_vfork */
c906108c SS	374	child_ops.to_insert_exec_catchpoint = NULL;
	375	child_ops.to_remove_exec_catchpoint = NULL;
	376	child_ops.to_has_execd = NULL;
	377	child_ops.to_reported_exec_events_per_exec_call = NULL;
	378	child_ops.to_has_exited = NULL;
c5aa993b JM	379	child_ops.to_mourn_inferior = child_mourn_inferior;
	380	child_ops.to_can_run = child_can_run;
	381	child_ops.to_notice_signals = 0;
	382	child_ops.to_thread_alive = 0;
	383	child_ops.to_stop = child_stop;
	384	child_ops.to_pid_to_exec_file = NULL; /* to_pid_to_exec_file */
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	}