* f-exp.y (yyparse): Add code to support exponentiation expression.

[binutils.git] / gdb / remote-rdp.c

diff --git a/gdb/remote-rdp.c b/gdb/remote-rdp.c
index 11d18d1a1c2ffef3d0c86f099f9eb97697c5a221..a1f54f79d3c53195213ff34fc55053581c2a9a4e 100644 (file)
--- a/gdb/remote-rdp.c
+++ b/gdb/remote-rdp.c
@@ -1,6 +1,7 @@
 /* Remote debugging for the ARM RDP interface.
 /* Remote debugging for the ARM RDP interface.

-   Copyright 1994, 1995, 1998, 1999, 2000, 2001
-   Free Software Foundation, Inc.
+
+   Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003 Free
+   Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -40,7 +41,7 @@
 #include "defs.h"
 #include "inferior.h"
 #include "value.h"
 #include "defs.h"
 #include "inferior.h"
 #include "value.h"

-#include "callback.h"
+#include "gdb/callback.h"

 #include "command.h"
 #include <ctype.h>
 #include <fcntl.h>
 #include "command.h"
 #include <ctype.h>
 #include <fcntl.h>


@@ -51,6 +52,8 @@
 #include "regcache.h"
 #include "serial.h"
 
 #include "regcache.h"
 #include "serial.h"
 

+#include "arm-tdep.h"
+

 #ifdef HAVE_TIME_H
 #include <time.h>
 #endif
 #ifdef HAVE_TIME_H
 #include <time.h>
 #endif


@@ -180,7 +183,7 @@ remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
 static unsigned char
 get_byte (void)
 {
 static unsigned char
 get_byte (void)
 {

-  int c = SERIAL_READCHAR (io, timeout);
+  int c = serial_readchar (io, timeout);

 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);


@@ -190,7 +193,7 @@ get_byte (void)
       if (timeout == 0)
        return (unsigned char) c;
 
       if (timeout == 0)
        return (unsigned char) c;
 

-      error ("Timeout reading from remote_system");
+      error (_("Timeout reading from remote_system"));

     }
 
   return c;
     }
 
   return c;


@@ -217,7 +220,7 @@ put_byte (char val)
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);

-  SERIAL_WRITE (io, &val, 1);
+  serial_write (io, &val, 1);

 }
 
 static void
 }
 
 static void


@@ -233,7 +236,7 @@ put_word (int val)
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
 

-  SERIAL_WRITE (io, b, 4);
+  serial_write (io, b, 4);

 }
 
 
 }
 
 


@@ -264,8 +267,8 @@ rdp_init (int cold, int tty)
       int restype;
       QUIT;
 
       int restype;
       QUIT;
 

-      SERIAL_FLUSH_INPUT (io);
-      SERIAL_FLUSH_OUTPUT (io);
+      serial_flush_input (io);
+      serial_flush_output (io);

 
       if (tty)
        printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
 
       if (tty)
        printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);


@@ -277,7 +280,7 @@ rdp_init (int cold, int tty)
       if (cold)
        {
          put_byte (RDP_RESET);
       if (cold)
        {
          put_byte (RDP_RESET);

-         while ((restype = SERIAL_READCHAR (io, 1)) > 0)
+         while ((restype = serial_readchar (io, 1)) > 0)

            {
              switch (restype)
                {
            {
              switch (restype)
                {


@@ -304,7 +307,7 @@ rdp_init (int cold, int tty)
       put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
       put_word (0);
 
       put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
       put_word (0);
 

-      while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
+      while (!sync && (restype = serial_readchar (io, 1)) > 0)

        {
          if (remote_debug)
            fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
        {
          if (remote_debug)
            fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);


@@ -315,13 +318,13 @@ rdp_init (int cold, int tty)
              break;
 
            case RDP_RESET:
              break;
 
            case RDP_RESET:

-             while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
+             while ((restype = serial_readchar (io, 1)) == RDP_RESET)

                ;
              do
                {
                  printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
                }
                ;
              do
                {
                  printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
                }

-             while ((restype = SERIAL_READCHAR (io, 1)) > 0);
+             while ((restype = serial_readchar (io, 1)) > 0);

 
              if (tty)
                {
 
              if (tty)
                {


@@ -339,7 +342,7 @@ rdp_init (int cold, int tty)
 
            case RDP_RES_VALUE:
              {
 
            case RDP_RES_VALUE:
              {

-               int resval = SERIAL_READCHAR (io, 1);
+               int resval = serial_readchar (io, 1);

 
                if (remote_debug)
                  fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
 
                if (remote_debug)
                  fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);


@@ -349,11 +352,29 @@ rdp_init (int cold, int tty)
                  case SERIAL_TIMEOUT:
                    break;
                  case RDP_RES_VALUE_LITTLE_ENDIAN:
                  case SERIAL_TIMEOUT:
                    break;
                  case RDP_RES_VALUE_LITTLE_ENDIAN:

-                   target_byte_order = LITTLE_ENDIAN;
+#if 0
+                   /* FIXME: cagney/2003-11-22: Ever since the ARM
+                       was multi-arched (in 2002-02-08), this
+                       assignment has had no effect.  There needs to
+                       be some sort of check/decision based on the
+                       current architecture's byte-order vs the remote
+                       target's byte order.  For the moment disable
+                       the assignment to keep things building.  */
+                   target_byte_order = BFD_ENDIAN_LITTLE;
+#endif

                    sync = 1;
                    break;
                  case RDP_RES_VALUE_BIG_ENDIAN:
                    sync = 1;
                    break;
                  case RDP_RES_VALUE_BIG_ENDIAN:

-                   target_byte_order = BIG_ENDIAN;
+#if 0
+                   /* FIXME: cagney/2003-11-22: Ever since the ARM
+                       was multi-arched (in 2002-02-08), this
+                       assignment has had no effect.  There needs to
+                       be some sort of check/decision based on the
+                       current architecture's byte-order vs the remote
+                       target's byte order.  For the moment disable
+                       the assignment to keep things building.  */
+                   target_byte_order = BFD_ENDIAN_BIG;
+#endif

                    sync = 1;
                    break;
                  default:
                    sync = 1;
                    break;
                  default:


@@ -366,12 +387,12 @@ rdp_init (int cold, int tty)
 
   if (!sync)
     {
 
   if (!sync)
     {

-      error ("Couldn't reset the board, try pressing the reset button");
+      error (_("Couldn't reset the board, try pressing the reset button"));

     }
 }
 
 
     }
 }
 
 

-void
+static void

 send_rdp (char *template,...)
 {
   char buf[200];
 send_rdp (char *template,...)
 {
   char buf[200];


@@ -433,10 +454,10 @@ send_rdp (char *template,...)
              printf_unfiltered ("RDP: Unimplemented message\n");
              return;
            case 255:
              printf_unfiltered ("RDP: Unimplemented message\n");
              return;
            case 255:

-             error ("Command garbled");
+             error (_("Command garbled"));

              break;
            default:
              break;
            default:

-             error ("Corrupt reply from target");
+             error (_("Corrupt reply from target"));

              break;
            }
          break;
              break;
            }
          break;


@@ -459,13 +480,13 @@ send_rdp (char *template,...)
          pc = va_arg (alist, char *);
          val = va_arg (alist, int);
          dst = buf;
          pc = va_arg (alist, char *);
          val = va_arg (alist, int);
          dst = buf;

-         SERIAL_WRITE (io, pc, val);
+         serial_write (io, pc, val);

          break;
        case '-':
          /* Send whats in the queue */
          if (dst != buf)
            {
          break;
        case '-':
          /* Send whats in the queue */
          if (dst != buf)
            {

-             SERIAL_WRITE (io, buf, dst - buf);
+             serial_write (io, buf, dst - buf);

              dst = buf;
            }
          break;
              dst = buf;
            }
          break;


@@ -474,13 +495,13 @@ send_rdp (char *template,...)
          *pi = get_byte ();
          break;
        default:
          *pi = get_byte ();
          break;
        default:

-         internal_error (__FILE__, __LINE__, "failed internal consistency check");
+         internal_error (__FILE__, __LINE__, _("failed internal consistency check"));

        }
     }
   va_end (alist);
 
   if (dst != buf)
        }
     }
   va_end (alist);
 
   if (dst != buf)

-    internal_error (__FILE__, __LINE__, "failed internal consistency check");
+    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));

 }
 
 
 }
 
 


@@ -547,7 +568,7 @@ rdp_fetch_one_fpu_register (int mask, char *buf)
       send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
     }
 #endif
       send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
     }
 #endif

-  memset (buf, 0, MAX_REGISTER_RAW_SIZE);
+  memset (buf, 0, MAX_REGISTER_SIZE);

 }
 
 
 }
 
 


@@ -609,22 +630,22 @@ remote_rdp_fetch_register (int regno)
     }
   else
     {
     }
   else
     {

-      char buf[MAX_REGISTER_RAW_SIZE];
+      char buf[MAX_REGISTER_SIZE];

       if (regno < 15)
        rdp_fetch_one_register (1 << regno, buf);
       if (regno < 15)
        rdp_fetch_one_register (1 << regno, buf);

-      else if (regno == PC_REGNUM)
+      else if (regno == ARM_PC_REGNUM)

        rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
        rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);

-      else if (regno == PS_REGNUM)
+      else if (regno == ARM_PS_REGNUM)

        rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
        rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);

-      else if (regno == FPS_REGNUM)
+      else if (regno == ARM_FPS_REGNUM)

        rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
        rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);

-      else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
-       rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
+      else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+       rdp_fetch_one_fpu_register (1 << (regno - ARM_F0_REGNUM), buf);

       else
        {
          printf ("Help me with fetch reg %d\n", regno);
        }
       else
        {
          printf ("Help me with fetch reg %d\n", regno);
        }

-      supply_register (regno, buf);
+      regcache_raw_supply (current_regcache, regno, buf);

     }
 }
 
     }
 }
 


@@ -639,16 +660,16 @@ remote_rdp_store_register (int regno)
     }
   else
     {
     }
   else
     {

-      char tmp[MAX_REGISTER_RAW_SIZE];
-      read_register_gen (regno, tmp);
+      char tmp[MAX_REGISTER_SIZE];
+      deprecated_read_register_gen (regno, tmp);

       if (regno < 15)
        rdp_store_one_register (1 << regno, tmp);
       if (regno < 15)
        rdp_store_one_register (1 << regno, tmp);

-      else if (regno == PC_REGNUM)
+      else if (regno == ARM_PC_REGNUM)

        rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
        rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);

-      else if (regno == PS_REGNUM)
+      else if (regno == ARM_PS_REGNUM)

        rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
        rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);

-      else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
-       rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
+      else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+       rdp_store_one_fpu_register (1 << (regno - ARM_F0_REGNUM), tmp);

       else
        {
          printf ("Help me with reg %d\n", regno);
       else
        {
          printf ("Help me with reg %d\n", regno);


@@ -700,7 +721,7 @@ rdp_set_command_line (char *command, char *args)
   if (commandline != NULL)
     xfree (commandline);
 
   if (commandline != NULL)
     xfree (commandline);
 

-  xasprintf (&commandline, "%s %s", command, args);
+  commandline = xstrprintf ("%s %s", command, args);

 }
 
 static void
 }
 
 static void


@@ -967,7 +988,7 @@ handle_swi (void)
          break;
 
        default:
          break;
 
        default:

-         error ("Unimplemented SWI argument");
+         error (_("Unimplemented SWI argument"));

        }
 
       type = type >> 2;
        }
 
       type = type >> 2;


@@ -995,12 +1016,12 @@ rdp_execute_finish (void)
   while (running)
     {
       int res;
   while (running)
     {
       int res;

-      res = SERIAL_READCHAR (io, 1);
+      res = serial_readchar (io, 1);

       while (res == SERIAL_TIMEOUT)
        {
          QUIT;
          printf_filtered ("Waiting for target..\n");
       while (res == SERIAL_TIMEOUT)
        {
          QUIT;
          printf_filtered ("Waiting for target..\n");

-         res = SERIAL_READCHAR (io, 1);
+         res = serial_readchar (io, 1);

        }
 
       switch (res)
        }
 
       switch (res)


@@ -1032,7 +1053,7 @@ rdp_execute (void)
 }
 
 static int
 }
 
 static int

-remote_rdp_insert_breakpoint (CORE_ADDR addr, char *save)
+remote_rdp_insert_breakpoint (CORE_ADDR addr, bfd_byte *save)

 {
   int res;
   if (ds.rdi_level > 0)
 {
   int res;
   if (ds.rdi_level > 0)


@@ -1056,7 +1077,7 @@ remote_rdp_insert_breakpoint (CORE_ADDR addr, char *save)
 }
 
 static int
 }
 
 static int

-remote_rdp_remove_breakpoint (CORE_ADDR addr, char *save)
+remote_rdp_remove_breakpoint (CORE_ADDR addr, bfd_byte *save)

 {
   int res;
   if (ds.rdi_level > 0)
 {
   int res;
   if (ds.rdi_level > 0)


@@ -1091,7 +1112,7 @@ rdp_step (void)
   else
     {
       char handle[4];
   else
     {
       char handle[4];

-      CORE_ADDR pc = read_register (PC_REGNUM);
+      CORE_ADDR pc = read_register (ARM_PC_REGNUM);

       pc = arm_get_next_pc (pc);
       remote_rdp_insert_breakpoint (pc, handle);
       rdp_execute ();
       pc = arm_get_next_pc (pc);
       remote_rdp_insert_breakpoint (pc, handle);
       rdp_execute ();


@@ -1105,18 +1126,18 @@ remote_rdp_open (char *args, int from_tty)
   int not_icebreaker;
 
   if (!args)
   int not_icebreaker;
 
   if (!args)

-    error_no_arg ("serial port device name");
+    error_no_arg (_("serial port device name"));

 
   baud_rate = 9600;
 
   target_preopen (from_tty);
 
 
   baud_rate = 9600;
 
   target_preopen (from_tty);
 

-  io = SERIAL_OPEN (args);
+  io = serial_open (args);

 
   if (!io)
     perror_with_name (args);
 
 
   if (!io)
     perror_with_name (args);
 

-  SERIAL_RAW (io);
+  serial_raw (io);

 
   rdp_init (1, from_tty);
 
 
   rdp_init (1, from_tty);
 


@@ -1160,9 +1181,7 @@ remote_rdp_open (char *args, int from_tty)
   flush_cached_frames ();
   registers_changed ();
   stop_pc = read_pc ();
   flush_cached_frames ();
   registers_changed ();
   stop_pc = read_pc ();

-  set_current_frame (create_new_frame (read_fp (), stop_pc));
-  select_frame (get_current_frame (), 0);
-  print_stack_frame (selected_frame, -1, 1);
+  print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);

 }
 
 
 }
 
 


@@ -1174,7 +1193,7 @@ remote_rdp_close (int quitting)
 {
   callback->shutdown (callback);
   if (io)
 {
   callback->shutdown (callback);
   if (io)

-    SERIAL_CLOSE (io);
+    serial_close (io);

   io = 0;
 }
 
   io = 0;
 }
 


@@ -1246,9 +1265,8 @@ remote_rdp_prepare_to_store (void)
 
 static int
 remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
 
 static int
 remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,

-                                int write, 
-                                struct mem_attrib *attrib ATTRIBUTE_UNUSED,
-                                struct target_ops *target ATTRIBUTE_UNUSED)
+                                int write, struct mem_attrib *attrib,
+                                struct target_ops *target)

 {
   /* I infer from D Taylor's code that there's a limit on the amount
      we can transfer in one chunk.. */
 {
   /* I infer from D Taylor's code that there's a limit on the amount
      we can transfer in one chunk.. */


@@ -1333,12 +1351,13 @@ remote_rdp_files_info (struct target_ops *target)
 
 
 static void
 
 
 static void

-remote_rdp_create_inferior (char *exec_file, char *allargs, char **env)
+remote_rdp_create_inferior (char *exec_file, char *allargs, char **env,
+                           int from_tty)

 {
   CORE_ADDR entry_point;
 
   if (exec_file == 0 || exec_bfd == 0)
 {
   CORE_ADDR entry_point;
 
   if (exec_file == 0 || exec_bfd == 0)

-    error ("No executable file specified.");
+    error (_("No executable file specified."));

 
   entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 
 
   entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 


@@ -1361,13 +1380,6 @@ remote_rdp_create_inferior (char *exec_file, char *allargs, char **env)
   proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
 }
 
   proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
 }
 

-/* Accept any stray run/attach commands */
-static int
-remote_rdp_can_run (void)
-{
-  return 1;
-}
-

 /* Attach doesn't need to do anything */
 static void
 remote_rdp_attach (char *args, int from_tty)
 /* Attach doesn't need to do anything */
 static void
 remote_rdp_attach (char *args, int from_tty)


@@ -1388,64 +1400,30 @@ init_remote_rdp_ops (void)
   remote_rdp_ops.to_open = remote_rdp_open;
   remote_rdp_ops.to_close = remote_rdp_close;
   remote_rdp_ops.to_attach = remote_rdp_attach;
   remote_rdp_ops.to_open = remote_rdp_open;
   remote_rdp_ops.to_close = remote_rdp_close;
   remote_rdp_ops.to_attach = remote_rdp_attach;

-  remote_rdp_ops.to_post_attach = NULL;
-  remote_rdp_ops.to_require_attach = NULL;
-  remote_rdp_ops.to_detach = NULL;
-  remote_rdp_ops.to_require_detach = NULL;

   remote_rdp_ops.to_resume = remote_rdp_resume;
   remote_rdp_ops.to_wait = remote_rdp_wait;
   remote_rdp_ops.to_resume = remote_rdp_resume;
   remote_rdp_ops.to_wait = remote_rdp_wait;

-  remote_rdp_ops.to_post_wait = NULL;

   remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
   remote_rdp_ops.to_store_registers = remote_rdp_store_register;
   remote_rdp_ops.to_prepare_to_store = remote_rdp_prepare_to_store;
   remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
   remote_rdp_ops.to_store_registers = remote_rdp_store_register;
   remote_rdp_ops.to_prepare_to_store = remote_rdp_prepare_to_store;

-  remote_rdp_ops.to_xfer_memory = remote_rdp_xfer_inferior_memory;
+  remote_rdp_ops.deprecated_xfer_memory = remote_rdp_xfer_inferior_memory;

   remote_rdp_ops.to_files_info = remote_rdp_files_info;
   remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
   remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;
   remote_rdp_ops.to_files_info = remote_rdp_files_info;
   remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
   remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;

-  remote_rdp_ops.to_terminal_init = NULL;
-  remote_rdp_ops.to_terminal_inferior = NULL;
-  remote_rdp_ops.to_terminal_ours_for_output = NULL;
-  remote_rdp_ops.to_terminal_ours = NULL;
-  remote_rdp_ops.to_terminal_info = NULL;

   remote_rdp_ops.to_kill = remote_rdp_kill;
   remote_rdp_ops.to_load = generic_load;
   remote_rdp_ops.to_kill = remote_rdp_kill;
   remote_rdp_ops.to_load = generic_load;

-  remote_rdp_ops.to_lookup_symbol = NULL;

   remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;
   remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;

-  remote_rdp_ops.to_post_startup_inferior = NULL;
-  remote_rdp_ops.to_acknowledge_created_inferior = NULL;
-  remote_rdp_ops.to_clone_and_follow_inferior = NULL;
-  remote_rdp_ops.to_post_follow_inferior_by_clone = NULL;
-  remote_rdp_ops.to_insert_fork_catchpoint = NULL;
-  remote_rdp_ops.to_remove_fork_catchpoint = NULL;
-  remote_rdp_ops.to_insert_vfork_catchpoint = NULL;
-  remote_rdp_ops.to_remove_vfork_catchpoint = NULL;
-  remote_rdp_ops.to_has_forked = NULL;
-  remote_rdp_ops.to_has_vforked = NULL;
-  remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL;
-  remote_rdp_ops.to_post_follow_vfork = NULL;
-  remote_rdp_ops.to_insert_exec_catchpoint = NULL;
-  remote_rdp_ops.to_remove_exec_catchpoint = NULL;
-  remote_rdp_ops.to_has_execd = NULL;
-  remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL;
-  remote_rdp_ops.to_has_exited = NULL;

   remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;
   remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;

-  remote_rdp_ops.to_can_run = remote_rdp_can_run;
-  remote_rdp_ops.to_notice_signals = 0;
-  remote_rdp_ops.to_thread_alive = 0;
-  remote_rdp_ops.to_stop = 0;
-  remote_rdp_ops.to_pid_to_exec_file = NULL;

   remote_rdp_ops.to_stratum = process_stratum;
   remote_rdp_ops.to_stratum = process_stratum;

-  remote_rdp_ops.DONT_USE = NULL;

   remote_rdp_ops.to_has_all_memory = 1;
   remote_rdp_ops.to_has_memory = 1;
   remote_rdp_ops.to_has_stack = 1;
   remote_rdp_ops.to_has_registers = 1;
   remote_rdp_ops.to_has_execution = 1;
   remote_rdp_ops.to_has_all_memory = 1;
   remote_rdp_ops.to_has_memory = 1;
   remote_rdp_ops.to_has_stack = 1;
   remote_rdp_ops.to_has_registers = 1;
   remote_rdp_ops.to_has_execution = 1;

-  remote_rdp_ops.to_sections = NULL;
-  remote_rdp_ops.to_sections_end = NULL;

   remote_rdp_ops.to_magic = OPS_MAGIC;
 }
 
   remote_rdp_ops.to_magic = OPS_MAGIC;
 }
 

+extern initialize_file_ftype _initialize_remote_rdp; /* -Wmissing-prototypes */
+

 void
 _initialize_remote_rdp (void)
 {
 void
 _initialize_remote_rdp (void)
 {