gdb/remote-st.c

   1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
   2    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
   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 /* This file was derived from remote-eb.c, which did a similar job, but for
  22    an AMD-29K running EBMON.  That file was in turn derived from remote.c
  23    as mentioned in the following comment (left in for comic relief):
  24
  25   "This is like remote.c but is for an esoteric situation--
  26    having an a29k board in a PC hooked up to a unix machine with
  27    a serial line, and running ctty com1 on the PC, through which
  28    the unix machine can run ebmon.  Not to mention that the PC
  29    has PC/NFS, so it can access the same executables that gdb can,
  30    over the net in real time."
  31
  32    In reality, this module talks to a debug monitor called 'STDEBUG', which
  33    runs in a phone switch.  We communicate with STDEBUG via either a direct
  34    serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
  35    which in turn talks to the phone switch. */
  36
  37 #include "defs.h"
  38 #include "gdbcore.h"
  39 #include "target.h"
  40 #include "wait.h"
  41 #include <varargs.h>
  42 #include <signal.h>
  43 #include <string.h>
  44 #include <sys/types.h>
  45 #include "serial.h"
  46
  47 extern struct target_ops st2000_ops;            /* Forward declaration */
  48
  49 static void st2000_close();
  50 static void st2000_fetch_register();
  51 static void st2000_store_register();
  52
  53 #define LOG_FILE "st2000.log"
  54 #if defined (LOG_FILE)
  55 FILE *log_file;
  56 #endif
  57
  58 static int timeout = 24;
  59
  60 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
  61    st2000_open knows that we don't have a file open when the program
  62    starts.  */
  63
  64 static serial_t st2000_desc;
  65
  66 /* Send data to stdebug.  Works just like printf. */
  67
  68 static void
  69 printf_stdebug(va_alist)
  70      va_dcl
  71 {
  72   va_list args;
  73   char *pattern;
  74   char buf[200];
  75
  76   va_start(args);
  77
  78   pattern = va_arg(args, char *);
  79
  80   vsprintf(buf, pattern, args);
  81   if (SERIAL_WRITE(st2000_desc, buf, strlen(buf)))
  82     fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
  83 }
  84
  85 /* Read a character from the remote system, doing all the fancy timeout
  86    stuff.  */
  87
  88 static int
  89 readchar(timeout)
  90      int timeout;
  91 {
  92   int c;
  93
  94   c = SERIAL_READCHAR(st2000_desc, timeout);
  95
  96 #ifdef LOG_FILE
  97   putc(c & 0x7f, log_file);
  98 #endif
  99
 100   if (c >= 0)
 101     return c & 0x7f;
 102
 103   if (c == SERIAL_TIMEOUT)
 104     {
 105       if (timeout == 0)
 106         return c;               /* Polls shouldn't generate timeout errors */
 107
 108       error("Timeout reading from remote system.");
 109     }
 110
 111   perror_with_name("remote-st2000");
 112 }
 113
 114 /* Scan input from the remote system, until STRING is found.  If DISCARD is
 115    non-zero, then discard non-matching input, else print it out.
 116    Let the user break out immediately.  */
 117 static void
 118 expect(string, discard)
 119      char *string;
 120      int discard;
 121 {
 122   char *p = string;
 123   int c;
 124
 125   immediate_quit = 1;
 126   while (1)
 127     {
 128       c = readchar(timeout);
 129       if (c == *p++)
 130         {
 131           if (*p == '\0')
 132             {
 133               immediate_quit = 0;
 134               return;
 135             }
 136         }
 137       else
 138         {
 139           if (!discard)
 140             {
 141               fwrite(string, 1, (p - 1) - string, stdout);
 142               putchar((char)c);
 143               fflush(stdout);
 144             }
 145           p = string;
 146         }
 147     }
 148 }
 149
 150 /* Keep discarding input until we see the STDEBUG prompt.
 151
 152    The convention for dealing with the prompt is that you
 153    o give your command
 154    o *then* wait for the prompt.
 155
 156    Thus the last thing that a procedure does with the serial line
 157    will be an expect_prompt().  Exception:  st2000_resume does not
 158    wait for the prompt, because the terminal is being handed over
 159    to the inferior.  However, the next thing which happens after that
 160    is a st2000_wait which does wait for the prompt.
 161    Note that this includes abnormal exit, e.g. error().  This is
 162    necessary to prevent getting into states from which we can't
 163    recover.  */
 164 static void
 165 expect_prompt(discard)
 166      int discard;
 167 {
 168 #if defined (LOG_FILE)
 169   /* This is a convenient place to do this.  The idea is to do it often
 170      enough that we never lose much data if we terminate abnormally.  */
 171   fflush(log_file);
 172 #endif
 173   expect ("dbug> ", discard);
 174 }
 175
 176 /* Get a hex digit from the remote system & return its value.
 177    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 178 static int
 179 get_hex_digit(ignore_space)
 180      int ignore_space;
 181 {
 182   int ch;
 183   while (1)
 184     {
 185       ch = readchar(timeout);
 186       if (ch >= '0' && ch <= '9')
 187         return ch - '0';
 188       else if (ch >= 'A' && ch <= 'F')
 189         return ch - 'A' + 10;
 190       else if (ch >= 'a' && ch <= 'f')
 191         return ch - 'a' + 10;
 192       else if (ch == ' ' && ignore_space)
 193         ;
 194       else
 195         {
 196           expect_prompt(1);
 197           error("Invalid hex digit from remote system.");
 198         }
 199     }
 200 }
 201
 202 /* Get a byte from stdebug and put it in *BYT.  Accept any number
 203    leading spaces.  */
 204 static void
 205 get_hex_byte (byt)
 206      char *byt;
 207 {
 208   int val;
 209
 210   val = get_hex_digit (1) << 4;
 211   val |= get_hex_digit (0);
 212   *byt = val;
 213 }
 214
 215 /* Get N 32-bit words from remote, each preceded by a space,
 216    and put them in registers starting at REGNO.  */
 217 static void
 218 get_hex_regs (n, regno)
 219      int n;
 220      int regno;
 221 {
 222   long val;
 223   int i;
 224
 225   for (i = 0; i < n; i++)
 226     {
 227       int j;
 228
 229       val = 0;
 230       for (j = 0; j < 8; j++)
 231         val = (val << 4) + get_hex_digit (j == 0);
 232       supply_register (regno++, (char *) &val);
 233     }
 234 }
 235
 236 /* This is called not only when we first attach, but also when the
 237    user types "run" after having attached.  */
 238 static void
 239 st2000_create_inferior (execfile, args, env)
 240      char *execfile;
 241      char *args;
 242      char **env;
 243 {
 244   int entry_pt;
 245
 246   if (args && *args)
 247     error("Can't pass arguments to remote STDEBUG process");
 248
 249   if (execfile == 0 || exec_bfd == 0)
 250     error("No exec file specified");
 251
 252   entry_pt = (int) bfd_get_start_address (exec_bfd);
 253
 254 /* The "process" (board) is already stopped awaiting our commands, and
 255    the program is already downloaded.  We just set its PC and go.  */
 256
 257   clear_proceed_status ();
 258
 259   /* Tell wait_for_inferior that we've started a new process.  */
 260   init_wait_for_inferior ();
 261
 262   /* Set up the "saved terminal modes" of the inferior
 263      based on what modes we are starting it with.  */
 264   target_terminal_init ();
 265
 266   /* Install inferior's terminal modes.  */
 267   target_terminal_inferior ();
 268
 269   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 270   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 271 }
 272
 273 /* Open a connection to a remote debugger.
 274    NAME is the filename used for communication.  */
 275
 276 static int baudrate = 9600;
 277 static char dev_name[100];
 278
 279 static void
 280 st2000_open(args, from_tty)
 281      char *args;
 282      int from_tty;
 283 {
 284   int n;
 285   char junk[100];
 286
 287   target_preopen(from_tty);
 288
 289   n = sscanf(args, " %s %d %s", dev_name, &baudrate, junk);
 290
 291   if (n != 2)
 292     error("Bad arguments.  Usage: target st2000 <device> <speed>\n\
 293 or target st2000 <host> <port>\n");
 294
 295   st2000_close(0);
 296
 297   st2000_desc = SERIAL_OPEN(dev_name);
 298
 299   if (!st2000_desc)
 300     perror_with_name(dev_name);
 301
 302   SERIAL_SETBAUDRATE(st2000_desc, baudrate);
 303
 304   SERIAL_RAW(st2000_desc);
 305
 306   push_target(&st2000_ops);
 307
 308 #if defined (LOG_FILE)
 309   log_file = fopen (LOG_FILE, "w");
 310   if (log_file == NULL)
 311     perror_with_name (LOG_FILE);
 312 #endif
 313
 314   /* Hello?  Are you there?  */
 315   printf_stdebug("\003");       /* ^C wakes up dbug */
 316
 317   expect_prompt(1);
 318
 319   if (from_tty)
 320     printf("Remote %s connected to %s\n", target_shortname,
 321            dev_name);
 322 }
 323
 324 /* Close out all files and local state before this target loses control. */
 325
 326 static void
 327 st2000_close (quitting)
 328      int quitting;
 329 {
 330   SERIAL_CLOSE(st2000_desc);
 331
 332 #if defined (LOG_FILE)
 333   if (log_file) {
 334     if (ferror(log_file))
 335       fprintf(stderr, "Error writing log file.\n");
 336     if (fclose(log_file) != 0)
 337       fprintf(stderr, "Error closing log file.\n");
 338   }
 339 #endif
 340 }
 341
 342 /* Terminate the open connection to the remote debugger.
 343    Use this when you want to detach and do something else
 344    with your gdb.  */
 345 static void
 346 st2000_detach (from_tty)
 347      int from_tty;
 348 {
 349   pop_target();         /* calls st2000_close to do the real work */
 350   if (from_tty)
 351     printf ("Ending remote %s debugging\n", target_shortname);
 352 }
 353
 354 /* Tell the remote machine to resume.  */
 355
 356 static void
 357 st2000_resume (pid, step, sig)
 358      int pid, step, sig;
 359 {
 360   if (step)
 361     {
 362       printf_stdebug ("ST\r");
 363       /* Wait for the echo.  */
 364       expect ("ST\r", 1);
 365     }
 366   else
 367     {
 368       printf_stdebug ("GO\r");
 369       /* Swallow the echo.  */
 370       expect ("GO\r", 1);
 371     }
 372 }
 373
 374 /* Wait until the remote machine stops, then return,
 375    storing status in STATUS just as `wait' would.  */
 376
 377 static int
 378 st2000_wait (status)
 379      WAITTYPE *status;
 380 {
 381   int old_timeout = timeout;
 382
 383   WSETEXIT ((*status), 0);
 384
 385   timeout = 0;          /* Don't time out -- user program is running. */
 386
 387   expect_prompt(0);    /* Wait for prompt, outputting extraneous text */
 388
 389   WSETSTOP ((*status), SIGTRAP);
 390
 391   timeout = old_timeout;
 392
 393   return 0;
 394 }
 395
 396 /* Return the name of register number REGNO in the form input and output by
 397    STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
 398    STDEBUG wants.  Lets take advantage of that just as long as possible! */
 399
 400 static char *
 401 get_reg_name (regno)
 402      int regno;
 403 {
 404   static char buf[50];
 405   const char *p;
 406   char *b;
 407
 408   b = buf;
 409
 410   for (p = reg_names[regno]; *p; p++)
 411     *b++ = toupper(*p);
 412   *b = '\000';
 413
 414   return buf;
 415 }
 416
 417 /* Read the remote registers into the block REGS.  */
 418
 419 static void
 420 st2000_fetch_registers ()
 421 {
 422   int regno;
 423
 424   /* Yeah yeah, I know this is horribly inefficient.  But it isn't done
 425      very often...  I'll clean it up later.  */
 426
 427   for (regno = 0; regno <= PC_REGNUM; regno++)
 428     st2000_fetch_register(regno);
 429 }
 430
 431 /* Fetch register REGNO, or all registers if REGNO is -1.
 432    Returns errno value.  */
 433 static void
 434 st2000_fetch_register (regno)
 435      int regno;
 436 {
 437   if (regno == -1)
 438     st2000_fetch_registers ();
 439   else
 440     {
 441       char *name = get_reg_name (regno);
 442       printf_stdebug ("DR %s\r", name);
 443       expect (name, 1);
 444       expect (" : ", 1);
 445       get_hex_regs (1, regno);
 446       expect_prompt (1);
 447     }
 448   return;
 449 }
 450
 451 /* Store the remote registers from the contents of the block REGS.  */
 452
 453 static void
 454 st2000_store_registers ()
 455 {
 456   int regno;
 457
 458   for (regno = 0; regno <= PC_REGNUM; regno++)
 459     st2000_store_register(regno);
 460
 461   registers_changed ();
 462 }
 463
 464 /* Store register REGNO, or all if REGNO == 0.
 465    Return errno value.  */
 466 static void
 467 st2000_store_register (regno)
 468      int regno;
 469 {
 470   if (regno == -1)
 471     st2000_store_registers ();
 472   else
 473     {
 474       printf_stdebug ("PR %s %x\r", get_reg_name (regno),
 475                       read_register (regno));
 476
 477       expect_prompt (1);
 478     }
 479 }
 480
 481 /* Get ready to modify the registers array.  On machines which store
 482    individual registers, this doesn't need to do anything.  On machines
 483    which store all the registers in one fell swoop, this makes sure
 484    that registers contains all the registers from the program being
 485    debugged.  */
 486
 487 static void
 488 st2000_prepare_to_store ()
 489 {
 490   /* Do nothing, since we can store individual regs */
 491 }
 492
 493 static void
 494 st2000_files_info ()
 495 {
 496   printf ("\tAttached to %s at %d baud.\n",
 497           dev_name, baudrate);
 498 }
 499
 500 /* Copy LEN bytes of data from debugger memory at MYADDR
 501    to inferior's memory at MEMADDR.  Returns length moved.  */
 502 static int
 503 st2000_write_inferior_memory (memaddr, myaddr, len)
 504      CORE_ADDR memaddr;
 505      unsigned char *myaddr;
 506      int len;
 507 {
 508   int i;
 509
 510   for (i = 0; i < len; i++)
 511     {
 512       printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
 513       expect_prompt (1);
 514     }
 515   return len;
 516 }
 517
 518 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 519    at debugger address MYADDR.  Returns length moved.  */
 520 static int
 521 st2000_read_inferior_memory(memaddr, myaddr, len)
 522      CORE_ADDR memaddr;
 523      char *myaddr;
 524      int len;
 525 {
 526   int i;
 527
 528   /* Number of bytes read so far.  */
 529   int count;
 530
 531   /* Starting address of this pass.  */
 532   unsigned long startaddr;
 533
 534   /* Number of bytes to read in this pass.  */
 535   int len_this_pass;
 536
 537   /* Note that this code works correctly if startaddr is just less
 538      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 539      thing).  That is, something like
 540      st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 541      works--it never adds len to memaddr and gets 0.  */
 542   /* However, something like
 543      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 544      doesn't need to work.  Detect it and give up if there's an attempt
 545      to do that.  */
 546   if (((memaddr - 1) + len) < memaddr) {
 547     errno = EIO;
 548     return 0;
 549   }
 550
 551   startaddr = memaddr;
 552   count = 0;
 553   while (count < len)
 554     {
 555       len_this_pass = 16;
 556       if ((startaddr % 16) != 0)
 557         len_this_pass -= startaddr % 16;
 558       if (len_this_pass > (len - count))
 559         len_this_pass = (len - count);
 560
 561       printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
 562       expect (":  ", 1);
 563
 564       for (i = 0; i < len_this_pass; i++)
 565         get_hex_byte (&myaddr[count++]);
 566
 567       expect_prompt (1);
 568
 569       startaddr += len_this_pass;
 570     }
 571   return len;
 572 }
 573
 574 /* FIXME-someday!  Merge these two.  */
 575 static int
 576 st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 577      CORE_ADDR memaddr;
 578      char *myaddr;
 579      int len;
 580      int write;
 581      struct target_ops *target;         /* ignored */
 582 {
 583   if (write)
 584     return st2000_write_inferior_memory (memaddr, myaddr, len);
 585   else
 586     return st2000_read_inferior_memory (memaddr, myaddr, len);
 587 }
 588
 589 static void
 590 st2000_kill (args, from_tty)
 591      char *args;
 592      int from_tty;
 593 {
 594   return;               /* Ignore attempts to kill target system */
 595 }
 596
 597 /* Clean up when a program exits.
 598
 599    The program actually lives on in the remote processor's RAM, and may be
 600    run again without a download.  Don't leave it full of breakpoint
 601    instructions.  */
 602
 603 static void
 604 st2000_mourn_inferior ()
 605 {
 606   remove_breakpoints ();
 607   unpush_target (&st2000_ops);
 608   generic_mourn_inferior ();    /* Do all the proper things now */
 609 }
 610
 611 #define MAX_STDEBUG_BREAKPOINTS 16
 612
 613 extern int memory_breakpoint_size;
 614 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = {0};
 615
 616 static int
 617 st2000_insert_breakpoint (addr, shadow)
 618      CORE_ADDR addr;
 619      char *shadow;
 620 {
 621   int i;
 622
 623   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 624     if (breakaddr[i] == 0)
 625       {
 626         breakaddr[i] = addr;
 627
 628         st2000_read_inferior_memory(addr, shadow, memory_breakpoint_size);
 629         printf_stdebug("BR %x H\r", addr);
 630         expect_prompt(1);
 631         return 0;
 632       }
 633
 634   fprintf(stderr, "Too many breakpoints (> 16) for STDBUG\n");
 635   return 1;
 636 }
 637
 638 static int
 639 st2000_remove_breakpoint (addr, shadow)
 640      CORE_ADDR addr;
 641      char *shadow;
 642 {
 643   int i;
 644
 645   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 646     if (breakaddr[i] == addr)
 647       {
 648         breakaddr[i] = 0;
 649
 650         printf_stdebug("CB %d\r", i);
 651         expect_prompt(1);
 652         return 0;
 653       }
 654
 655   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
 656   return 1;
 657 }
 658
 659
 660 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
 661    on the users terminal until the prompt is seen. */
 662
 663 static void
 664 st2000_command (args, fromtty)
 665      char       *args;
 666      int        fromtty;
 667 {
 668   if (!st2000_desc)
 669     error("st2000 target not open.");
 670
 671   if (!args)
 672     error("Missing command.");
 673
 674   printf_stdebug("%s\r", args);
 675   expect_prompt(0);
 676 }
 677
 678 /* Connect the user directly to STDBUG.  This command acts just like the
 679    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 680
 681 /*static struct ttystate ttystate;*/
 682
 683 static void
 684 cleanup_tty()
 685 {
 686   printf("\r\n[Exiting connect mode]\r\n");
 687 /*  SERIAL_RESTORE(0, &ttystate);*/
 688 }
 689
 690 #if 0
 691 /* This all should now be in serial.c */
 692
 693 static void
 694 connect_command (args, fromtty)
 695      char       *args;
 696      int        fromtty;
 697 {
 698   fd_set readfds;
 699   int numfds;
 700   int c;
 701   char cur_esc = 0;
 702
 703   dont_repeat();
 704
 705   if (st2000_desc < 0)
 706     error("st2000 target not open.");
 707
 708   if (args)
 709     fprintf("This command takes no args.  They have been ignored.\n");
 710
 711   printf("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 712
 713   serial_raw(0, &ttystate);
 714
 715   make_cleanup(cleanup_tty, 0);
 716
 717   FD_ZERO(&readfds);
 718
 719   while (1)
 720     {
 721       do
 722         {
 723           FD_SET(0, &readfds);
 724           FD_SET(st2000_desc, &readfds);
 725           numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0);
 726         }
 727       while (numfds == 0);
 728
 729       if (numfds < 0)
 730         perror_with_name("select");
 731
 732       if (FD_ISSET(0, &readfds))
 733         {                       /* tty input, send to stdebug */
 734           c = getchar();
 735           if (c < 0)
 736             perror_with_name("connect");
 737
 738           printf_stdebug("%c", c);
 739           switch (cur_esc)
 740             {
 741             case 0:
 742               if (c == '\r')
 743                 cur_esc = c;
 744               break;
 745             case '\r':
 746               if (c == '~')
 747                 cur_esc = c;
 748               else
 749                 cur_esc = 0;
 750               break;
 751             case '~':
 752               if (c == '.' || c == '\004')
 753                 return;
 754               else
 755                 cur_esc = 0;
 756             }
 757         }
 758
 759       if (FD_ISSET(st2000_desc, &readfds))
 760         {
 761           while (1)
 762             {
 763               c = readchar(0);
 764               if (c < 0)
 765                 break;
 766               putchar(c);
 767             }
 768           fflush(stdout);
 769         }
 770     }
 771 }
 772 #endif /* 0 */
 773
 774 /* Define the target subroutine names */
 775
 776 struct target_ops st2000_ops = {
 777   "st2000",
 778   "Remote serial Tandem ST2000 target",
 779   "Use a remote computer running STDEBUG connected by a serial line,\n\
 780 or a network connection.\n\
 781 Arguments are the name of the device for the serial line,\n\
 782 the speed to connect at in bits per second.",
 783   st2000_open,
 784   st2000_close,
 785   0,
 786   st2000_detach,
 787   st2000_resume,
 788   st2000_wait,
 789   st2000_fetch_register,
 790   st2000_store_register,
 791   st2000_prepare_to_store,
 792   st2000_xfer_inferior_memory,
 793   st2000_files_info,
 794   st2000_insert_breakpoint,
 795   st2000_remove_breakpoint,     /* Breakpoints */
 796   0,
 797   0,
 798   0,
 799   0,
 800   0,                            /* Terminal handling */
 801   st2000_kill,
 802   0,                            /* load */
 803   0,                            /* lookup_symbol */
 804   st2000_create_inferior,
 805   st2000_mourn_inferior,
 806   0,                            /* can_run */
 807   0,                            /* notice_signals */
 808   process_stratum,
 809   0,                            /* next */
 810   1,
 811   1,
 812   1,
 813   1,
 814   1,                            /* all mem, mem, stack, regs, exec */
 815   0,
 816   0,                            /* Section pointers */
 817   OPS_MAGIC,                    /* Always the last thing */
 818 };
 819
 820 void
 821 _initialize_remote_st2000 ()
 822 {
 823   add_target (&st2000_ops);
 824   add_com ("st2000 <command>", class_obscure, st2000_command,
 825            "Send a command to the STDBUG monitor.");
 826   add_com ("connect", class_obscure, connect_command,
 827            "Connect the terminal directly up to the STDBUG command monitor.\n\
 828 Use <CR>~. or <CR>~^D to break out.");
 829 }