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