gdb/remote-utils.h

   1 /* Generic support for remote debugging interfaces.
   2
   3    Copyright 1993 Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   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.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #ifndef REMOTE_UTILS_H
  22 #define REMOTE_UTILS_H
  23
  24 #include "serial.h"
  25 #include "target.h"
  26 #include "dcache.h"
  27
  28 /* Stuff that should be shared (and handled consistently) among the various
  29    remote targets.  */
  30
  31 struct _sr_settings {
  32   unsigned int timeout;
  33
  34   int retries;
  35
  36   char *device;
  37   serial_t desc;
  38
  39 };
  40
  41 extern struct _sr_settings sr_settings;
  42 extern int remote_debug;
  43 extern int baud_rate;
  44
  45 /* get and set debug value. */
  46 #define sr_get_debug()                  (remote_debug)
  47 #define sr_set_debug(newval)            (remote_debug = (newval))
  48
  49 /* get and set baud rate. */
  50 #define sr_get_baud_rate()              (baud_rate)
  51 #define sr_set_baud_rate(newval)        (baud_rate = (newval))
  52
  53 /* get and set timeout. */
  54 #define sr_get_timeout()                (sr_settings.timeout)
  55 #define sr_set_timeout(newval)          (sr_settings.timeout = (newval))
  56
  57 /* get and set device. */
  58 #define sr_get_device()                 (sr_settings.device)
  59 #define sr_set_device(newval) \
  60 { \
  61     if (sr_settings.device) free(sr_settings.device); \
  62     sr_settings.device = (newval); \
  63 }
  64
  65 /* get and set descriptor value. */
  66 #define sr_get_desc()                   (sr_settings.desc)
  67 #define sr_set_desc(newval)             (sr_settings.desc = (newval))
  68
  69 /* get and set retries. */
  70 #define sr_get_retries()                (sr_settings.retries)
  71 #define sr_set_retries(newval)          (sr_settings.retries = (newval))
  72
  73 #define sr_is_open()                    (sr_settings.desc != NULL)
  74
  75 #define sr_check_open()         { if (!sr_is_open()) \
  76                                     error ("Remote device not open"); }
  77
  78 struct gr_settings {
  79   /* This is our data cache. */
  80   DCACHE *dcache;
  81   char *prompt;
  82   struct target_ops *ops;
  83   int (*clear_all_breakpoints)PARAMS((void));
  84   memxferfunc readfunc;
  85   memxferfunc writefunc;
  86   void (*checkin)PARAMS((void));
  87 };
  88
  89 extern struct gr_settings *gr_settings;
  90
  91 /* get and set dcache. */
  92 #define gr_get_dcache()                 (gr_settings->dcache)
  93 #define gr_set_dcache(newval)           (gr_settings->dcache = (newval))
  94
  95 /* get and set prompt. */
  96 #define gr_get_prompt()                 (gr_settings->prompt)
  97 #define gr_set_prompt(newval)           (gr_settings->prompt = (newval))
  98
  99 /* get and set ops. */
 100 #define gr_get_ops()                    (gr_settings->ops)
 101 #define gr_set_ops(newval)              (gr_settings->ops = (newval))
 102
 103 #define gr_clear_all_breakpoints()      ((gr_settings->clear_all_breakpoints)())
 104 #define gr_checkin()                    ((gr_settings->checkin)())
 105
 106 /* Keep discarding input until we see the prompt.
 107
 108    The convention for dealing with the prompt is that you
 109    o give your command
 110    o *then* wait for the prompt.
 111
 112    Thus the last thing that a procedure does with the serial line
 113    will be an gr_expect_prompt().  Exception:  resume does not
 114    wait for the prompt, because the terminal is being handed over
 115    to the inferior.  However, the next thing which happens after that
 116    is a bug_wait which does wait for the prompt.
 117    Note that this includes abnormal exit, e.g. error().  This is
 118    necessary to prevent getting into states from which we can't
 119    recover.  */
 120
 121 #define gr_expect_prompt()      sr_expect(gr_get_prompt())
 122
 123 int gr_fetch_word PARAMS((CORE_ADDR addr));
 124 int gr_multi_scan PARAMS((char *list[], int passthrough));
 125 int sr_get_hex_digit PARAMS((int ignore_space));
 126 int sr_pollchar PARAMS((void));
 127 int sr_readchar PARAMS((void));
 128 int sr_timed_read PARAMS((char *buf, int n));
 129 long sr_get_hex_word PARAMS((void));
 130 void gr_close PARAMS((int quitting));
 131 void gr_create_inferior PARAMS((char *execfile, char *args, char **env));
 132 void gr_detach PARAMS((char *args, int from_tty));
 133 void gr_files_info PARAMS((struct target_ops *ops));
 134 void gr_generic_checkin PARAMS((void));
 135 void gr_kill PARAMS((void));
 136 void gr_mourn PARAMS((void));
 137 void gr_prepare_to_store PARAMS((void));
 138 void gr_store_word PARAMS((CORE_ADDR addr, int word));
 139 void sr_expect PARAMS((char *string));
 140 void sr_get_hex_byte PARAMS((char *byt));
 141 void sr_scan_args PARAMS((char *proto, char *args));
 142 void sr_write PARAMS((char *a, int l));
 143 void sr_write_cr PARAMS((char *s));
 144
 145 void gr_open PARAMS((char *args, int from_tty,
 146                      struct gr_settings *gr_settings));
 147
 148
 149 #endif /* REMOTE_UTILS_H */