contrib/gdb-7/gdb/serial.c

   1 /* Generic serial interface routines
   2
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   4    2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include <ctype.h>
  24 #include "serial.h"
  25 #include "gdb_string.h"
  26 #include "gdbcmd.h"
  27
  28 extern void _initialize_serial (void);
  29
  30 /* Is serial being debugged?  */
  31
  32 static int global_serial_debug_p;
  33
  34 /* Linked list of serial I/O handlers.  */
  35
  36 static struct serial_ops *serial_ops_list = NULL;
  37
  38 /* This is the last serial stream opened.  Used by connect command.  */
  39
  40 static struct serial *last_serial_opened = NULL;
  41
  42 /* Pointer to list of scb's.  */
  43
  44 static struct serial *scb_base;
  45
  46 /* Non-NULL gives filename which contains a recording of the remote session,
  47    suitable for playback by gdbserver.  */
  48
  49 static char *serial_logfile = NULL;
  50 static struct ui_file *serial_logfp = NULL;
  51
  52 static struct serial_ops *serial_interface_lookup (const char *);
  53 static void serial_logchar (struct ui_file *stream,
  54                             int ch_type, int ch, int timeout);
  55 static const char logbase_hex[] = "hex";
  56 static const char logbase_octal[] = "octal";
  57 static const char logbase_ascii[] = "ascii";
  58 static const char *logbase_enums[] =
  59 {logbase_hex, logbase_octal, logbase_ascii, NULL};
  60 static const char *serial_logbase = logbase_ascii;
  61 \f
  62
  63 static int serial_current_type = 0;
  64
  65 /* Log char CH of type CHTYPE, with TIMEOUT.  */
  66
  67 /* Define bogus char to represent a BREAK.  Should be careful to choose a value
  68    that can't be confused with a normal char, or an error code.  */
  69 #define SERIAL_BREAK 1235
  70
  71 static void
  72 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
  73 {
  74   if (ch_type != serial_current_type)
  75     {
  76       fprintf_unfiltered (stream, "\n%c ", ch_type);
  77       serial_current_type = ch_type;
  78     }
  79
  80   if (serial_logbase != logbase_ascii)
  81     fputc_unfiltered (' ', stream);
  82
  83   switch (ch)
  84     {
  85     case SERIAL_TIMEOUT:
  86       fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
  87       return;
  88     case SERIAL_ERROR:
  89       fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
  90       return;
  91     case SERIAL_EOF:
  92       fputs_unfiltered ("<Eof>", stream);
  93       return;
  94     case SERIAL_BREAK:
  95       fputs_unfiltered ("<Break>", stream);
  96       return;
  97     default:
  98       if (serial_logbase == logbase_hex)
  99         fprintf_unfiltered (stream, "%02x", ch & 0xff);
 100       else if (serial_logbase == logbase_octal)
 101         fprintf_unfiltered (stream, "%03o", ch & 0xff);
 102       else
 103         switch (ch)
 104           {
 105           case '\\':
 106             fputs_unfiltered ("\\\\", stream);
 107             break;
 108           case '\b':
 109             fputs_unfiltered ("\\b", stream);
 110             break;
 111           case '\f':
 112             fputs_unfiltered ("\\f", stream);
 113             break;
 114           case '\n':
 115             fputs_unfiltered ("\\n", stream);
 116             break;
 117           case '\r':
 118             fputs_unfiltered ("\\r", stream);
 119             break;
 120           case '\t':
 121             fputs_unfiltered ("\\t", stream);
 122             break;
 123           case '\v':
 124             fputs_unfiltered ("\\v", stream);
 125             break;
 126           default:
 127             fprintf_unfiltered (stream,
 128                                 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
 129             break;
 130           }
 131     }
 132 }
 133
 134 void
 135 serial_log_command (const char *cmd)
 136 {
 137   if (!serial_logfp)
 138     return;
 139
 140   serial_current_type = 'c';
 141
 142   fputs_unfiltered ("\nc ", serial_logfp);
 143   fputs_unfiltered (cmd, serial_logfp);
 144
 145   /* Make sure that the log file is as up-to-date as possible,
 146      in case we are getting ready to dump core or something.  */
 147   gdb_flush (serial_logfp);
 148 }
 149
 150 \f
 151 static struct serial_ops *
 152 serial_interface_lookup (const char *name)
 153 {
 154   struct serial_ops *ops;
 155
 156   for (ops = serial_ops_list; ops; ops = ops->next)
 157     if (strcmp (name, ops->name) == 0)
 158       return ops;
 159
 160   return NULL;
 161 }
 162
 163 void
 164 serial_add_interface (struct serial_ops *optable)
 165 {
 166   optable->next = serial_ops_list;
 167   serial_ops_list = optable;
 168 }
 169
 170 /* Open up a device or a network socket, depending upon the syntax of NAME.  */
 171
 172 struct serial *
 173 serial_open (const char *name)
 174 {
 175   struct serial *scb;
 176   struct serial_ops *ops;
 177   const char *open_name = name;
 178
 179   for (scb = scb_base; scb; scb = scb->next)
 180     if (scb->name && strcmp (scb->name, name) == 0)
 181       {
 182         scb->refcnt++;
 183         return scb;
 184       }
 185
 186   if (strcmp (name, "pc") == 0)
 187     ops = serial_interface_lookup ("pc");
 188   else if (strncmp (name, "lpt", 3) == 0)
 189     ops = serial_interface_lookup ("parallel");
 190   else if (strncmp (name, "|", 1) == 0)
 191     {
 192       ops = serial_interface_lookup ("pipe");
 193       /* Discard ``|'' and any space before the command itself.  */
 194       ++open_name;
 195       while (isspace (*open_name))
 196         ++open_name;
 197     }
 198   /* Check for a colon, suggesting an IP address/port pair.
 199      Do this *after* checking for all the interesting prefixes.  We
 200      don't want to constrain the syntax of what can follow them.  */
 201   else if (strchr (name, ':'))
 202     ops = serial_interface_lookup ("tcp");
 203   else
 204     ops = serial_interface_lookup ("hardwire");
 205
 206   if (!ops)
 207     return NULL;
 208
 209   scb = XMALLOC (struct serial);
 210
 211   scb->ops = ops;
 212
 213   scb->bufcnt = 0;
 214   scb->bufp = scb->buf;
 215   scb->error_fd = -1;
 216
 217   /* `...->open (...)' would get expanded by the open(2) syscall macro.  */
 218   if ((*scb->ops->open) (scb, open_name))
 219     {
 220       xfree (scb);
 221       return NULL;
 222     }
 223
 224   scb->name = xstrdup (name);
 225   scb->next = scb_base;
 226   scb->refcnt = 1;
 227   scb->debug_p = 0;
 228   scb->async_state = 0;
 229   scb->async_handler = NULL;
 230   scb->async_context = NULL;
 231   scb_base = scb;
 232
 233   last_serial_opened = scb;
 234
 235   if (serial_logfile != NULL)
 236     {
 237       serial_logfp = gdb_fopen (serial_logfile, "w");
 238       if (serial_logfp == NULL)
 239         perror_with_name (serial_logfile);
 240     }
 241
 242   return scb;
 243 }
 244
 245 /* Return the open serial device for FD, if found, or NULL if FD
 246    is not already opened.  */
 247
 248 struct serial *
 249 serial_for_fd (int fd)
 250 {
 251   struct serial *scb;
 252
 253   for (scb = scb_base; scb; scb = scb->next)
 254     if (scb->fd == fd)
 255       return scb;
 256
 257   return NULL;
 258 }
 259
 260 /* Open a new serial stream using a file handle, using serial
 261    interface ops OPS.  */
 262
 263 static struct serial *
 264 serial_fdopen_ops (const int fd, struct serial_ops *ops)
 265 {
 266   struct serial *scb;
 267
 268   scb = serial_for_fd (fd);
 269   if (scb)
 270     {
 271       scb->refcnt++;
 272       return scb;
 273     }
 274
 275   if (!ops)
 276     {
 277       ops = serial_interface_lookup ("terminal");
 278       if (!ops)
 279         ops = serial_interface_lookup ("hardwire");
 280     }
 281
 282   if (!ops)
 283     return NULL;
 284
 285   scb = XCALLOC (1, struct serial);
 286
 287   scb->ops = ops;
 288
 289   scb->bufcnt = 0;
 290   scb->bufp = scb->buf;
 291   scb->error_fd = -1;
 292
 293   scb->name = NULL;
 294   scb->next = scb_base;
 295   scb->refcnt = 1;
 296   scb->debug_p = 0;
 297   scb->async_state = 0;
 298   scb->async_handler = NULL;
 299   scb->async_context = NULL;
 300   scb_base = scb;
 301
 302   if ((ops->fdopen) != NULL)
 303     (*ops->fdopen) (scb, fd);
 304   else
 305     scb->fd = fd;
 306
 307   last_serial_opened = scb;
 308
 309   return scb;
 310 }
 311
 312 struct serial *
 313 serial_fdopen (const int fd)
 314 {
 315   return serial_fdopen_ops (fd, NULL);
 316 }
 317
 318 static void
 319 do_serial_close (struct serial *scb, int really_close)
 320 {
 321   struct serial *tmp_scb;
 322
 323   last_serial_opened = NULL;
 324
 325   if (serial_logfp)
 326     {
 327       fputs_unfiltered ("\nEnd of log\n", serial_logfp);
 328       serial_current_type = 0;
 329
 330       /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr?  */
 331       ui_file_delete (serial_logfp);
 332       serial_logfp = NULL;
 333     }
 334
 335 /* This is bogus.  It's not our fault if you pass us a bad scb...!  Rob, you
 336    should fix your code instead.  */
 337
 338   if (!scb)
 339     return;
 340
 341   scb->refcnt--;
 342   if (scb->refcnt > 0)
 343     return;
 344
 345   /* ensure that the FD has been taken out of async mode.  */
 346   if (scb->async_handler != NULL)
 347     serial_async (scb, NULL, NULL);
 348
 349   if (really_close)
 350     scb->ops->close (scb);
 351
 352   if (scb->name)
 353     xfree (scb->name);
 354
 355   if (scb_base == scb)
 356     scb_base = scb_base->next;
 357   else
 358     for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
 359       {
 360         if (tmp_scb->next != scb)
 361           continue;
 362
 363         tmp_scb->next = tmp_scb->next->next;
 364         break;
 365       }
 366
 367   xfree (scb);
 368 }
 369
 370 void
 371 serial_close (struct serial *scb)
 372 {
 373   do_serial_close (scb, 1);
 374 }
 375
 376 void
 377 serial_un_fdopen (struct serial *scb)
 378 {
 379   do_serial_close (scb, 0);
 380 }
 381
 382 int
 383 serial_readchar (struct serial *scb, int timeout)
 384 {
 385   int ch;
 386
 387   /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
 388      code is finished.  */
 389   if (0 && serial_is_async_p (scb) && timeout < 0)
 390     internal_error (__FILE__, __LINE__,
 391                     _("serial_readchar: blocking read in async mode"));
 392
 393   ch = scb->ops->readchar (scb, timeout);
 394   if (serial_logfp != NULL)
 395     {
 396       serial_logchar (serial_logfp, 'r', ch, timeout);
 397
 398       /* Make sure that the log file is as up-to-date as possible,
 399          in case we are getting ready to dump core or something.  */
 400       gdb_flush (serial_logfp);
 401     }
 402   if (serial_debug_p (scb))
 403     {
 404       fprintf_unfiltered (gdb_stdlog, "[");
 405       serial_logchar (gdb_stdlog, 'r', ch, timeout);
 406       fprintf_unfiltered (gdb_stdlog, "]");
 407       gdb_flush (gdb_stdlog);
 408     }
 409
 410   return (ch);
 411 }
 412
 413 int
 414 serial_write (struct serial *scb, const char *str, int len)
 415 {
 416   if (serial_logfp != NULL)
 417     {
 418       int count;
 419
 420       for (count = 0; count < len; count++)
 421         serial_logchar (serial_logfp, 'w', str[count] & 0xff, 0);
 422
 423       /* Make sure that the log file is as up-to-date as possible,
 424          in case we are getting ready to dump core or something.  */
 425       gdb_flush (serial_logfp);
 426     }
 427   if (serial_debug_p (scb))
 428     {
 429       int count;
 430
 431       for (count = 0; count < len; count++)
 432         {
 433           fprintf_unfiltered (gdb_stdlog, "[");
 434           serial_logchar (gdb_stdlog, 'w', str[count] & 0xff, 0);
 435           fprintf_unfiltered (gdb_stdlog, "]");
 436         }
 437       gdb_flush (gdb_stdlog);
 438     }
 439
 440   return (scb->ops->write (scb, str, len));
 441 }
 442
 443 void
 444 serial_printf (struct serial *desc, const char *format,...)
 445 {
 446   va_list args;
 447   char *buf;
 448   va_start (args, format);
 449
 450   buf = xstrvprintf (format, args);
 451   serial_write (desc, buf, strlen (buf));
 452
 453   xfree (buf);
 454   va_end (args);
 455 }
 456
 457 int
 458 serial_drain_output (struct serial *scb)
 459 {
 460   return scb->ops->drain_output (scb);
 461 }
 462
 463 int
 464 serial_flush_output (struct serial *scb)
 465 {
 466   return scb->ops->flush_output (scb);
 467 }
 468
 469 int
 470 serial_flush_input (struct serial *scb)
 471 {
 472   return scb->ops->flush_input (scb);
 473 }
 474
 475 int
 476 serial_send_break (struct serial *scb)
 477 {
 478   if (serial_logfp != NULL)
 479     serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
 480
 481   return (scb->ops->send_break (scb));
 482 }
 483
 484 void
 485 serial_raw (struct serial *scb)
 486 {
 487   scb->ops->go_raw (scb);
 488 }
 489
 490 serial_ttystate
 491 serial_get_tty_state (struct serial *scb)
 492 {
 493   return scb->ops->get_tty_state (scb);
 494 }
 495
 496 serial_ttystate
 497 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
 498 {
 499   return scb->ops->copy_tty_state (scb, ttystate);
 500 }
 501
 502 int
 503 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 504 {
 505   return scb->ops->set_tty_state (scb, ttystate);
 506 }
 507
 508 void
 509 serial_print_tty_state (struct serial *scb,
 510                         serial_ttystate ttystate,
 511                         struct ui_file *stream)
 512 {
 513   scb->ops->print_tty_state (scb, ttystate, stream);
 514 }
 515
 516 int
 517 serial_noflush_set_tty_state (struct serial *scb,
 518                               serial_ttystate new_ttystate,
 519                               serial_ttystate old_ttystate)
 520 {
 521   return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
 522 }
 523
 524 int
 525 serial_setbaudrate (struct serial *scb, int rate)
 526 {
 527   return scb->ops->setbaudrate (scb, rate);
 528 }
 529
 530 int
 531 serial_setstopbits (struct serial *scb, int num)
 532 {
 533   return scb->ops->setstopbits (scb, num);
 534 }
 535
 536 int
 537 serial_can_async_p (struct serial *scb)
 538 {
 539   return (scb->ops->async != NULL);
 540 }
 541
 542 int
 543 serial_is_async_p (struct serial *scb)
 544 {
 545   return (scb->ops->async != NULL) && (scb->async_handler != NULL);
 546 }
 547
 548 void
 549 serial_async (struct serial *scb,
 550               serial_event_ftype *handler,
 551               void *context)
 552 {
 553   int changed = ((scb->async_handler == NULL) != (handler == NULL));
 554
 555   scb->async_handler = handler;
 556   scb->async_context = context;
 557   /* Only change mode if there is a need.  */
 558   if (changed)
 559     scb->ops->async (scb, handler != NULL);
 560 }
 561
 562 int
 563 deprecated_serial_fd (struct serial *scb)
 564 {
 565   /* FIXME: should this output a warning that deprecated code is being
 566      called?  */
 567   if (scb->fd < 0)
 568     {
 569       internal_error (__FILE__, __LINE__,
 570                       _("serial: FD not valid"));
 571     }
 572   return scb->fd; /* sigh */
 573 }
 574
 575 void
 576 serial_debug (struct serial *scb, int debug_p)
 577 {
 578   scb->debug_p = debug_p;
 579 }
 580
 581 int
 582 serial_debug_p (struct serial *scb)
 583 {
 584   return scb->debug_p || global_serial_debug_p;
 585 }
 586
 587 #ifdef USE_WIN32API
 588 void
 589 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
 590 {
 591   if (scb->ops->wait_handle)
 592     scb->ops->wait_handle (scb, read, except);
 593   else
 594     {
 595       *read = (HANDLE) _get_osfhandle (scb->fd);
 596       *except = NULL;
 597     }
 598 }
 599
 600 void
 601 serial_done_wait_handle (struct serial *scb)
 602 {
 603   if (scb->ops->done_wait_handle)
 604     scb->ops->done_wait_handle (scb);
 605 }
 606 #endif
 607
 608 int
 609 serial_pipe (struct serial *scbs[2])
 610 {
 611   struct serial_ops *ops;
 612   int fildes[2];
 613
 614   ops = serial_interface_lookup ("pipe");
 615   if (!ops)
 616     {
 617       errno = ENOSYS;
 618       return -1;
 619     }
 620
 621   if (gdb_pipe (fildes) == -1)
 622     return -1;
 623
 624   scbs[0] = serial_fdopen_ops (fildes[0], ops);
 625   scbs[1] = serial_fdopen_ops (fildes[1], ops);
 626   return 0;
 627 }
 628
 629 #if 0
 630 /* The connect command is #if 0 because I hadn't thought of an elegant
 631    way to wait for I/O on two `struct serial *'s simultaneously.  Two
 632    solutions came to mind:
 633
 634    1) Fork, and have have one fork handle the to user direction,
 635    and have the other hand the to target direction.  This
 636    obviously won't cut it for MSDOS.
 637
 638    2) Use something like select.  This assumes that stdin and
 639    the target side can both be waited on via the same
 640    mechanism.  This may not be true for DOS, if GDB is
 641    talking to the target via a TCP socket.
 642    -grossman, 8 Jun 93 */
 643
 644 /* Connect the user directly to the remote system.  This command acts just like
 645    the 'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 646
 647 static struct serial *tty_desc; /* Controlling terminal */
 648
 649 static void
 650 cleanup_tty (serial_ttystate ttystate)
 651 {
 652   printf_unfiltered ("\r\n[Exiting connect mode]\r\n");
 653   serial_set_tty_state (tty_desc, ttystate);
 654   xfree (ttystate);
 655   serial_close (tty_desc);
 656 }
 657
 658 static void
 659 connect_command (char *args, int fromtty)
 660 {
 661   int c;
 662   char cur_esc = 0;
 663   serial_ttystate ttystate;
 664   struct serial *port_desc;             /* TTY port */
 665
 666   dont_repeat ();
 667
 668   if (args)
 669     fprintf_unfiltered (gdb_stderr,
 670                         "This command takes no args.  "
 671                         "They have been ignored.\n");
 672
 673   printf_unfiltered ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 674
 675   tty_desc = serial_fdopen (0);
 676   port_desc = last_serial_opened;
 677
 678   ttystate = serial_get_tty_state (tty_desc);
 679
 680   serial_raw (tty_desc);
 681   serial_raw (port_desc);
 682
 683   make_cleanup (cleanup_tty, ttystate);
 684
 685   while (1)
 686     {
 687       int mask;
 688
 689       mask = serial_wait_2 (tty_desc, port_desc, -1);
 690
 691       if (mask & 2)
 692         {                       /* tty input */
 693           char cx;
 694
 695           while (1)
 696             {
 697               c = serial_readchar (tty_desc, 0);
 698
 699               if (c == SERIAL_TIMEOUT)
 700                 break;
 701
 702               if (c < 0)
 703                 perror_with_name (_("connect"));
 704
 705               cx = c;
 706               serial_write (port_desc, &cx, 1);
 707
 708               switch (cur_esc)
 709                 {
 710                 case 0:
 711                   if (c == '\r')
 712                     cur_esc = c;
 713                   break;
 714                 case '\r':
 715                   if (c == '~')
 716                     cur_esc = c;
 717                   else
 718                     cur_esc = 0;
 719                   break;
 720                 case '~':
 721                   if (c == '.' || c == '\004')
 722                     return;
 723                   else
 724                     cur_esc = 0;
 725                 }
 726             }
 727         }
 728
 729       if (mask & 1)
 730         {                       /* Port input */
 731           char cx;
 732
 733           while (1)
 734             {
 735               c = serial_readchar (port_desc, 0);
 736
 737               if (c == SERIAL_TIMEOUT)
 738                 break;
 739
 740               if (c < 0)
 741                 perror_with_name (_("connect"));
 742
 743               cx = c;
 744
 745               serial_write (tty_desc, &cx, 1);
 746             }
 747         }
 748     }
 749 }
 750 #endif /* 0 */
 751
 752 /* Serial set/show framework.  */
 753
 754 static struct cmd_list_element *serial_set_cmdlist;
 755 static struct cmd_list_element *serial_show_cmdlist;
 756
 757 static void
 758 serial_set_cmd (char *args, int from_tty)
 759 {
 760   printf_unfiltered ("\"set serial\" must be followed "
 761                      "by the name of a command.\n");
 762   help_list (serial_set_cmdlist, "set serial ", -1, gdb_stdout);
 763 }
 764
 765 static void
 766 serial_show_cmd (char *args, int from_tty)
 767 {
 768   cmd_show_list (serial_show_cmdlist, from_tty, "");
 769 }
 770
 771
 772 void
 773 _initialize_serial (void)
 774 {
 775 #if 0
 776   add_com ("connect", class_obscure, connect_command, _("\
 777 Connect the terminal directly up to the command monitor.\n\
 778 Use <CR>~. or <CR>~^D to break out."));
 779 #endif /* 0 */
 780
 781   add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
 782 Set default serial/parallel port configuration."),
 783                   &serial_set_cmdlist, "set serial ",
 784                   0/*allow-unknown*/,
 785                   &setlist);
 786
 787   add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
 788 Show default serial/parallel port configuration."),
 789                   &serial_show_cmdlist, "show serial ",
 790                   0/*allow-unknown*/,
 791                   &showlist);
 792
 793   add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
 794 Set filename for remote session recording."), _("\
 795 Show filename for remote session recording."), _("\
 796 This file is used to record the remote session for future playback\n\
 797 by gdbserver."),
 798                             NULL,
 799                             NULL, /* FIXME: i18n: */
 800                             &setlist, &showlist);
 801
 802   add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
 803                         &serial_logbase, _("\
 804 Set numerical base for remote session logging"), _("\
 805 Show numerical base for remote session logging"), NULL,
 806                         NULL,
 807                         NULL, /* FIXME: i18n: */
 808                         &setlist, &showlist);
 809
 810   add_setshow_zinteger_cmd ("serial", class_maintenance,
 811                             &global_serial_debug_p, _("\
 812 Set serial debugging."), _("\
 813 Show serial debugging."), _("\
 814 When non-zero, serial port debugging is enabled."),
 815                             NULL,
 816                             NULL, /* FIXME: i18n: */
 817                             &setdebuglist, &showdebuglist);
 818 }