X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fremote-st.c;h=c2bcf3d00f91822084bef5c5a5daf7f226921d10;hb=b2182ed226dfa161296df892b2f12650d67c0ba0;hp=582ab2fe1170ec71c51c4981a1ac8738b6c6b328;hpb=5d76c8e66273baf43bfee19c3341e605d4a09ad8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/remote-st.c b/gdb/remote-st.c index 582ab2fe11..c2bcf3d00f 100644 --- a/gdb/remote-st.c +++ b/gdb/remote-st.c @@ -1,28 +1,32 @@ /* Remote debugging interface for Tandem ST2000 phone switch, for GDB. - Copyright 1990, 1991, 1992 Free Software Foundation, Inc. + + Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, + 2001, 2002, 2006 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /* This file was derived from remote-eb.c, which did a similar job, but for an AMD-29K running EBMON. That file was in turn derived from remote.c as mentioned in the following comment (left in for comic relief): - "This is like remote.c but is for an esoteric situation-- + "This is like remote.c but is for an esoteric situation-- having an a29k board in a PC hooked up to a unix machine with a serial line, and running ctty com1 on the PC, through which the unix machine can run ebmon. Not to mention that the PC @@ -32,23 +36,21 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ In reality, this module talks to a debug monitor called 'STDEBUG', which runs in a phone switch. We communicate with STDEBUG via either a direct serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor, - which in turn talks to the phone switch. */ + which in turn talks to the phone switch. */ #include "defs.h" #include "gdbcore.h" #include "target.h" -#include "wait.h" -#include -#include -#include +#include "gdb_string.h" #include #include "serial.h" +#include "regcache.h" -extern struct target_ops st2000_ops; /* Forward declaration */ +extern struct target_ops st2000_ops; /* Forward declaration */ -static void st2000_close(); -static void st2000_fetch_register(); -static void st2000_store_register(); +static void st2000_close (); +static void st2000_fetch_register (); +static void st2000_store_register (); #define LOG_FILE "st2000.log" #if defined (LOG_FILE) @@ -61,40 +63,38 @@ static int timeout = 24; st2000_open knows that we don't have a file open when the program starts. */ -static serial_t st2000_desc; +static struct serial *st2000_desc; /* Send data to stdebug. Works just like printf. */ static void -printf_stdebug(va_alist) - va_dcl +printf_stdebug (char *pattern,...) { va_list args; - char *pattern; char buf[200]; - va_start(args); + va_start (args, pattern); - pattern = va_arg(args, char *); + vsprintf (buf, pattern, args); + va_end (args); - vsprintf(buf, pattern, args); - if (SERIAL_WRITE(st2000_desc, buf, strlen(buf))) - fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno)); + if (serial_write (st2000_desc, buf, strlen (buf))) + fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", + safe_strerror (errno)); } /* Read a character from the remote system, doing all the fancy timeout stuff. */ static int -readchar(timeout) - int timeout; +readchar (int timeout) { int c; - c = SERIAL_READCHAR(st2000_desc, timeout); + c = serial_readchar (st2000_desc, timeout); #ifdef LOG_FILE - putc(c & 0x7f, log_file); + putc (c & 0x7f, log_file); #endif if (c >= 0) @@ -105,32 +105,30 @@ readchar(timeout) if (timeout == 0) return c; /* Polls shouldn't generate timeout errors */ - error("Timeout reading from remote system."); + error (_("Timeout reading from remote system.")); } - perror_with_name("remote-st2000"); + perror_with_name (_("remote-st2000")); } /* Scan input from the remote system, until STRING is found. If DISCARD is non-zero, then discard non-matching input, else print it out. Let the user break out immediately. */ static void -expect(string, discard) - char *string; - int discard; +expect (char *string, int discard) { char *p = string; int c; - immediate_quit = 1; + immediate_quit++; while (1) { - c = readchar(timeout); + c = readchar (timeout); if (c == *p++) { if (*p == '\0') { - immediate_quit = 0; + immediate_quit--; return; } } @@ -138,9 +136,9 @@ expect(string, discard) { if (!discard) { - fwrite(string, 1, (p - 1) - string, stdout); - putchar((char)c); - fflush(stdout); + fwrite (string, 1, (p - 1) - string, stdout); + putchar ((char) c); + fflush (stdout); } p = string; } @@ -162,13 +160,12 @@ expect(string, discard) necessary to prevent getting into states from which we can't recover. */ static void -expect_prompt(discard) - int discard; +expect_prompt (int discard) { #if defined (LOG_FILE) /* This is a convenient place to do this. The idea is to do it often enough that we never lose much data if we terminate abnormally. */ - fflush(log_file); + fflush (log_file); #endif expect ("dbug> ", discard); } @@ -176,13 +173,12 @@ expect_prompt(discard) /* Get a hex digit from the remote system & return its value. If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */ static int -get_hex_digit(ignore_space) - int ignore_space; +get_hex_digit (int ignore_space) { int ch; while (1) { - ch = readchar(timeout); + ch = readchar (timeout); if (ch >= '0' && ch <= '9') return ch - '0'; else if (ch >= 'A' && ch <= 'F') @@ -193,8 +189,8 @@ get_hex_digit(ignore_space) ; else { - expect_prompt(1); - error("Invalid hex digit from remote system."); + expect_prompt (1); + error (_("Invalid hex digit from remote system.")); } } } @@ -202,8 +198,7 @@ get_hex_digit(ignore_space) /* Get a byte from stdebug and put it in *BYT. Accept any number leading spaces. */ static void -get_hex_byte (byt) - char *byt; +get_hex_byte (char *byt) { int val; @@ -215,9 +210,7 @@ get_hex_byte (byt) /* Get N 32-bit words from remote, each preceded by a space, and put them in registers starting at REGNO. */ static void -get_hex_regs (n, regno) - int n; - int regno; +get_hex_regs (int n, int regno) { long val; int i; @@ -225,29 +218,27 @@ get_hex_regs (n, regno) for (i = 0; i < n; i++) { int j; - + val = 0; for (j = 0; j < 8; j++) val = (val << 4) + get_hex_digit (j == 0); - supply_register (regno++, (char *) &val); + regcache_raw_supply (current_regcache, regno++, (char *) &val); } } /* This is called not only when we first attach, but also when the user types "run" after having attached. */ static void -st2000_create_inferior (execfile, args, env) - char *execfile; - char *args; - char **env; +st2000_create_inferior (char *execfile, char *args, char **env, + int from_tty) { int entry_pt; if (args && *args) - error("Can't pass arguments to remote STDEBUG process"); + error (_("Can't pass arguments to remote STDEBUG process")); if (execfile == 0 || exec_bfd == 0) - error("No exec file specified"); + error (_("No executable file specified")); entry_pt = (int) bfd_get_start_address (exec_bfd); @@ -267,7 +258,7 @@ st2000_create_inferior (execfile, args, env) target_terminal_inferior (); /* insert_step_breakpoint (); FIXME, do we need this? */ - proceed ((CORE_ADDR)entry_pt, -1, 0); /* Let 'er rip... */ + write_pc ((CORE_ADDR) entry_pt); } /* Open a connection to a remote debugger. @@ -277,65 +268,67 @@ static int baudrate = 9600; static char dev_name[100]; static void -st2000_open(args, from_tty) - char *args; - int from_tty; +st2000_open (char *args, int from_tty) { int n; char junk[100]; - target_preopen(from_tty); - - n = sscanf(args, " %s %d %s", dev_name, &baudrate, junk); + target_preopen (from_tty); + + n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk); if (n != 2) - error("Bad arguments. Usage: target st2000 \n\ -or target st2000 \n"); + error (_("Bad arguments. Usage: target st2000 \n\ +or target st2000 \n")); - st2000_close(0); + st2000_close (0); - st2000_desc = SERIAL_OPEN(dev_name); + st2000_desc = serial_open (dev_name); if (!st2000_desc) - perror_with_name(dev_name); + perror_with_name (dev_name); - SERIAL_SETBAUDRATE(st2000_desc, baudrate); + if (serial_setbaudrate (st2000_desc, baudrate)) + { + serial_close (dev_name); + perror_with_name (dev_name); + } - SERIAL_RAW(st2000_desc); + serial_raw (st2000_desc); - push_target(&st2000_ops); + push_target (&st2000_ops); #if defined (LOG_FILE) log_file = fopen (LOG_FILE, "w"); if (log_file == NULL) - perror_with_name (LOG_FILE); + perror_with_name ((LOG_FILE)); #endif /* Hello? Are you there? */ - printf_stdebug("\003"); /* ^C wakes up dbug */ - - expect_prompt(1); + printf_stdebug ("\003"); /* ^C wakes up dbug */ + + expect_prompt (1); if (from_tty) - printf("Remote %s connected to %s\n", target_shortname, - dev_name); + printf ("Remote %s connected to %s\n", target_shortname, + dev_name); } /* Close out all files and local state before this target loses control. */ static void -st2000_close (quitting) - int quitting; +st2000_close (int quitting) { - SERIAL_CLOSE(st2000_desc); + serial_close (st2000_desc); #if defined (LOG_FILE) - if (log_file) { - if (ferror(log_file)) - fprintf(stderr, "Error writing log file.\n"); - if (fclose(log_file) != 0) - fprintf(stderr, "Error closing log file.\n"); - } + if (log_file) + { + if (ferror (log_file)) + fprintf_unfiltered (gdb_stderr, "Error writing log file.\n"); + if (fclose (log_file) != 0) + fprintf_unfiltered (gdb_stderr, "Error closing log file.\n"); + } #endif } @@ -343,19 +336,17 @@ st2000_close (quitting) Use this when you want to detach and do something else with your gdb. */ static void -st2000_detach (from_tty) - int from_tty; +st2000_detach (int from_tty) { - pop_target(); /* calls st2000_close to do the real work */ + pop_target (); /* calls st2000_close to do the real work */ if (from_tty) printf ("Ending remote %s debugging\n", target_shortname); } - + /* Tell the remote machine to resume. */ static void -st2000_resume (pid, step, sig) - int pid, step, sig; +st2000_resume (ptid_t ptid, int step, enum target_signal sig) { if (step) { @@ -374,32 +365,33 @@ st2000_resume (pid, step, sig) /* Wait until the remote machine stops, then return, storing status in STATUS just as `wait' would. */ -static int -st2000_wait (status) - WAITTYPE *status; +static ptid_t +st2000_wait (ptid_t ptid, struct target_waitstatus *status) { int old_timeout = timeout; - WSETEXIT ((*status), 0); + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; - timeout = 0; /* Don't time out -- user program is running. */ + timeout = 0; /* Don't time out -- user program is running. */ - expect_prompt(0); /* Wait for prompt, outputting extraneous text */ + expect_prompt (0); /* Wait for prompt, outputting extraneous text */ - WSETSTOP ((*status), SIGTRAP); + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TRAP; timeout = old_timeout; - return 0; + return inferior_ptid; } -/* Return the name of register number REGNO in the form input and output by - STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what - STDEBUG wants. Lets take advantage of that just as long as possible! */ +/* Return the name of register number REGNO in the form input and + output by STDEBUG. Currently, REGISTER_NAME just happens return + exactly what STDEBUG wants. Lets take advantage of that just as + long as possible! */ static char * -get_reg_name (regno) - int regno; +get_reg_name (int regno) { static char buf[50]; const char *p; @@ -407,8 +399,8 @@ get_reg_name (regno) b = buf; - for (p = reg_names[regno]; *p; p++) - *b++ = toupper(*p); + for (p = REGISTER_NAME (regno); *p; p++) + *b++ = toupper (*p); *b = '\000'; return buf; @@ -417,7 +409,7 @@ get_reg_name (regno) /* Read the remote registers into the block REGS. */ static void -st2000_fetch_registers () +st2000_fetch_registers (void) { int regno; @@ -425,14 +417,13 @@ st2000_fetch_registers () very often... I'll clean it up later. */ for (regno = 0; regno <= PC_REGNUM; regno++) - st2000_fetch_register(regno); + st2000_fetch_register (regno); } /* Fetch register REGNO, or all registers if REGNO is -1. Returns errno value. */ static void -st2000_fetch_register (regno) - int regno; +st2000_fetch_register (int regno) { if (regno == -1) st2000_fetch_registers (); @@ -451,12 +442,12 @@ st2000_fetch_register (regno) /* Store the remote registers from the contents of the block REGS. */ static void -st2000_store_registers () +st2000_store_registers (void) { int regno; for (regno = 0; regno <= PC_REGNUM; regno++) - st2000_store_register(regno); + st2000_store_register (regno); registers_changed (); } @@ -464,8 +455,7 @@ st2000_store_registers () /* Store register REGNO, or all if REGNO == 0. Return errno value. */ static void -st2000_store_register (regno) - int regno; +st2000_store_register (int regno) { if (regno == -1) st2000_store_registers (); @@ -485,13 +475,13 @@ st2000_store_register (regno) debugged. */ static void -st2000_prepare_to_store () +st2000_prepare_to_store (void) { /* Do nothing, since we can store individual regs */ } static void -st2000_files_info () +st2000_files_info (void) { printf ("\tAttached to %s at %d baud.\n", dev_name, baudrate); @@ -500,10 +490,7 @@ st2000_files_info () /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory at MEMADDR. Returns length moved. */ static int -st2000_write_inferior_memory (memaddr, myaddr, len) - CORE_ADDR memaddr; - unsigned char *myaddr; - int len; +st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) { int i; @@ -518,10 +505,7 @@ st2000_write_inferior_memory (memaddr, myaddr, len) /* Read LEN bytes from inferior memory at MEMADDR. Put the result at debugger address MYADDR. Returns length moved. */ static int -st2000_read_inferior_memory(memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) { int i; @@ -543,11 +527,12 @@ st2000_read_inferior_memory(memaddr, myaddr, len) st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4) doesn't need to work. Detect it and give up if there's an attempt to do that. */ - if (((memaddr - 1) + len) < memaddr) { - errno = EIO; - return 0; - } - + if (((memaddr - 1) + len) < memaddr) + { + errno = EIO; + return 0; + } + startaddr = memaddr; count = 0; while (count < len) @@ -571,14 +556,16 @@ st2000_read_inferior_memory(memaddr, myaddr, len) return len; } -/* FIXME-someday! Merge these two. */ +/* Transfer LEN bytes between GDB address MYADDR and target address + MEMADDR. If WRITE is non-zero, transfer them to the target, + otherwise transfer them from the target. TARGET is unused. + + Returns the number of bytes transferred. */ + static int -st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *target; /* ignored */ +st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, + int write, struct mem_attrib *attrib, + struct target_ops *target) { if (write) return st2000_write_inferior_memory (memaddr, myaddr, len); @@ -587,11 +574,9 @@ st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target) } static void -st2000_kill (args, from_tty) - char *args; - int from_tty; +st2000_kill (char *args, int from_tty) { - return; /* Ignore attempts to kill target system */ + return; /* Ignore attempts to kill target system */ } /* Clean up when a program exits. @@ -601,7 +586,7 @@ st2000_kill (args, from_tty) instructions. */ static void -st2000_mourn_inferior () +st2000_mourn_inferior (void) { remove_breakpoints (); unpush_target (&st2000_ops); @@ -610,14 +595,13 @@ st2000_mourn_inferior () #define MAX_STDEBUG_BREAKPOINTS 16 -extern int memory_breakpoint_size; -static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = {0}; +static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = +{0}; static int -st2000_insert_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +st2000_insert_breakpoint (struct bp_target_info *bp_tgt) { + CORE_ADDR addr = bp_tgt->placed_address; int i; for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++) @@ -625,21 +609,19 @@ st2000_insert_breakpoint (addr, shadow) { breakaddr[i] = addr; - st2000_read_inferior_memory(addr, shadow, memory_breakpoint_size); - printf_stdebug("BR %x H\r", addr); - expect_prompt(1); + printf_stdebug ("BR %x H\r", addr); + expect_prompt (1); return 0; } - fprintf(stderr, "Too many breakpoints (> 16) for STDBUG\n"); + fprintf_unfiltered (gdb_stderr, "Too many breakpoints (> 16) for STDBUG\n"); return 1; } static int -st2000_remove_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +st2000_remove_breakpoint (struct bp_target_info *bp_tgt) { + CORE_ADDR addr = bp_tgt->placed_address; int i; for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++) @@ -647,12 +629,13 @@ st2000_remove_breakpoint (addr, shadow) { breakaddr[i] = 0; - printf_stdebug("CB %d\r", i); - expect_prompt(1); + printf_stdebug ("CB %d\r", i); + expect_prompt (1); return 0; } - fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr); + fprintf_unfiltered (gdb_stderr, + "Can't find breakpoint associated with 0x%x\n", addr); return 1; } @@ -661,81 +644,77 @@ st2000_remove_breakpoint (addr, shadow) on the users terminal until the prompt is seen. */ static void -st2000_command (args, fromtty) - char *args; - int fromtty; +st2000_command (char *args, int fromtty) { if (!st2000_desc) - error("st2000 target not open."); - + error (_("st2000 target not open.")); + if (!args) - error("Missing command."); - - printf_stdebug("%s\r", args); - expect_prompt(0); + error (_("Missing command.")); + + printf_stdebug ("%s\r", args); + expect_prompt (0); } /* Connect the user directly to STDBUG. This command acts just like the 'cu' or 'tip' command. Use ~. or ~^D to break out. */ -/*static struct ttystate ttystate;*/ +/*static struct ttystate ttystate; */ static void -cleanup_tty() +cleanup_tty (void) { - printf("\r\n[Exiting connect mode]\r\n"); -/* SERIAL_RESTORE(0, &ttystate);*/ + printf ("\r\n[Exiting connect mode]\r\n"); +/* serial_restore(0, &ttystate); */ } #if 0 /* This all should now be in serial.c */ static void -connect_command (args, fromtty) - char *args; - int fromtty; +connect_command (char *args, int fromtty) { fd_set readfds; int numfds; int c; char cur_esc = 0; - dont_repeat(); + dont_repeat (); if (st2000_desc < 0) - error("st2000 target not open."); - + error (_("st2000 target not open.")); + if (args) - fprintf("This command takes no args. They have been ignored.\n"); - - printf("[Entering connect mode. Use ~. or ~^D to escape]\n"); + fprintf ("This command takes no args. They have been ignored.\n"); + + printf ("[Entering connect mode. Use ~. or ~^D to escape]\n"); - serial_raw(0, &ttystate); + serial_raw (0, &ttystate); - make_cleanup(cleanup_tty, 0); + make_cleanup (cleanup_tty, 0); - FD_ZERO(&readfds); + FD_ZERO (&readfds); while (1) { do { - FD_SET(0, &readfds); - FD_SET(st2000_desc, &readfds); - numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0); + FD_SET (0, &readfds); + FD_SET (deprecated_serial_fd (st2000_desc), &readfds); + numfds = gdb_select (sizeof (readfds) * 8, &readfds, 0, 0, 0); } while (numfds == 0); if (numfds < 0) - perror_with_name("select"); + perror_with_name (("select")); - if (FD_ISSET(0, &readfds)) + if (FD_ISSET (0, &readfds)) { /* tty input, send to stdebug */ - c = getchar(); + c = getchar (); if (c < 0) - perror_with_name("connect"); + perror_with_name (("connect")); - printf_stdebug("%c", c); + printf_stdebug ("%c", c); switch (cur_esc) { case 0: @@ -756,16 +735,16 @@ connect_command (args, fromtty) } } - if (FD_ISSET(st2000_desc, &readfds)) + if (FD_ISSET (deprecated_serial_fd (st2000_desc), &readfds)) { while (1) { - c = readchar(0); + c = readchar (0); if (c < 0) break; - putchar(c); + putchar (c); } - fflush(stdout); + fflush (stdout); } } } @@ -773,57 +752,49 @@ connect_command (args, fromtty) /* Define the target subroutine names */ -struct target_ops st2000_ops = { - "st2000", - "Remote serial Tandem ST2000 target", - "Use a remote computer running STDEBUG connected by a serial line,\n\ +struct target_ops st2000_ops; + +static void +init_st2000_ops (void) +{ + st2000_ops.to_shortname = "st2000"; + st2000_ops.to_longname = "Remote serial Tandem ST2000 target"; + st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\ or a network connection.\n\ Arguments are the name of the device for the serial line,\n\ -the speed to connect at in bits per second.", - st2000_open, - st2000_close, - 0, - st2000_detach, - st2000_resume, - st2000_wait, - st2000_fetch_register, - st2000_store_register, - st2000_prepare_to_store, - st2000_xfer_inferior_memory, - st2000_files_info, - st2000_insert_breakpoint, - st2000_remove_breakpoint, /* Breakpoints */ - 0, - 0, - 0, - 0, - 0, /* Terminal handling */ - st2000_kill, - 0, /* load */ - 0, /* lookup_symbol */ - st2000_create_inferior, - st2000_mourn_inferior, - 0, /* can_run */ - 0, /* notice_signals */ - process_stratum, - 0, /* next */ - 1, - 1, - 1, - 1, - 1, /* all mem, mem, stack, regs, exec */ - 0, - 0, /* Section pointers */ - OPS_MAGIC, /* Always the last thing */ +the speed to connect at in bits per second."; + st2000_ops.to_open = st2000_open; + st2000_ops.to_close = st2000_close; + st2000_ops.to_detach = st2000_detach; + st2000_ops.to_resume = st2000_resume; + st2000_ops.to_wait = st2000_wait; + st2000_ops.to_fetch_registers = st2000_fetch_register; + st2000_ops.to_store_registers = st2000_store_register; + st2000_ops.to_prepare_to_store = st2000_prepare_to_store; + st2000_ops.deprecated_xfer_memory = st2000_xfer_inferior_memory; + st2000_ops.to_files_info = st2000_files_info; + st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint; + st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint; /* Breakpoints */ + st2000_ops.to_kill = st2000_kill; + st2000_ops.to_create_inferior = st2000_create_inferior; + st2000_ops.to_mourn_inferior = st2000_mourn_inferior; + st2000_ops.to_stratum = process_stratum; + st2000_ops.to_has_all_memory = 1; + st2000_ops.to_has_memory = 1; + st2000_ops.to_has_stack = 1; + st2000_ops.to_has_registers = 1; + st2000_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */ + st2000_ops.to_magic = OPS_MAGIC; /* Always the last thing */ }; void -_initialize_remote_st2000 () +_initialize_remote_st2000 (void) { + init_st2000_ops (); add_target (&st2000_ops); - add_com ("st2000 ", class_obscure, st2000_command, - "Send a command to the STDBUG monitor."); - add_com ("connect", class_obscure, connect_command, - "Connect the terminal directly up to the STDBUG command monitor.\n\ -Use ~. or ~^D to break out."); + add_com ("st2000", class_obscure, st2000_command, + _("Send a command to the STDBUG monitor.")); + add_com ("connect", class_obscure, connect_command, _("\ +Connect the terminal directly up to the STDBUG command monitor.\n\ +Use ~. or ~^D to break out.")); }