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

/* Target-vector operations for controlling Mac applications, for GDB.
   Copyright (C) 1995 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 "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 <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 PARAMS ((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 (args, from_tty)
     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 (args, from_tty)
     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 (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));
}

/* ARGSUSED */
static void
child_open (arg, from_tty)
     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 (exec_file, allargs, env)
     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 ()
{
  unpush_target (&child_ops);
  generic_mourn_inferior ();
}

static void
child_stop ()
{
}

int
child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
		   int write, 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 ()
{
  /* Do nothing, since we can store individual regs */
}

static int
child_can_run ()
{
  return 1;
}

static void
child_close ()
{
}

static void
info_proc (args, from_tty)
     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 ()
{
  init_child_ops ();

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