]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/serial.c
Assume termios is available, remove support for termio and sgtty
[thirdparty/binutils-gdb.git] / gdb / serial.c
CommitLineData
c906108c 1/* Generic serial interface routines
4fcf66da 2
61baf725 3 Copyright (C) 1992-2017 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#include "defs.h"
21#include <ctype.h>
22#include "serial.h"
c906108c 23#include "gdbcmd.h"
529480d0 24#include "cli/cli-utils.h"
c906108c 25
c378eb4e 26/* Is serial being debugged? */
2acceee2 27
ccce17b0 28static unsigned int global_serial_debug_p;
2acceee2 29
fcd488ca
TT
30typedef const struct serial_ops *serial_ops_p;
31DEF_VEC_P (serial_ops_p);
c906108c 32
fcd488ca
TT
33/* Serial I/O handlers. */
34
35VEC (serial_ops_p) *serial_ops_list = NULL;
c906108c 36
5eb3b062
PA
37/* Pointer to list of scb's. */
38
39static struct serial *scb_base;
40
c906108c 41/* Non-NULL gives filename which contains a recording of the remote session,
c378eb4e 42 suitable for playback by gdbserver. */
c906108c
SS
43
44static char *serial_logfile = NULL;
d9fcf2fb 45static struct ui_file *serial_logfp = NULL;
c906108c 46
fcd488ca 47static const struct serial_ops *serial_interface_lookup (const char *);
3e43a32a
MS
48static void serial_logchar (struct ui_file *stream,
49 int ch_type, int ch, int timeout);
53904c9e
AC
50static const char logbase_hex[] = "hex";
51static const char logbase_octal[] = "octal";
52static const char logbase_ascii[] = "ascii";
40478521 53static const char *const logbase_enums[] =
c5aa993b 54{logbase_hex, logbase_octal, logbase_ascii, NULL};
53904c9e 55static const char *serial_logbase = logbase_ascii;
c906108c 56\f
c5aa993b 57
c906108c
SS
58static int serial_current_type = 0;
59
c378eb4e 60/* Log char CH of type CHTYPE, with TIMEOUT. */
c906108c
SS
61
62/* Define bogus char to represent a BREAK. Should be careful to choose a value
63 that can't be confused with a normal char, or an error code. */
64#define SERIAL_BREAK 1235
65
66static void
d9fcf2fb 67serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
c906108c
SS
68{
69 if (ch_type != serial_current_type)
70 {
2acceee2 71 fprintf_unfiltered (stream, "\n%c ", ch_type);
c906108c
SS
72 serial_current_type = ch_type;
73 }
74
75 if (serial_logbase != logbase_ascii)
2acceee2 76 fputc_unfiltered (' ', stream);
c906108c
SS
77
78 switch (ch)
79 {
80 case SERIAL_TIMEOUT:
2acceee2 81 fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
c906108c
SS
82 return;
83 case SERIAL_ERROR:
2acceee2 84 fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
c906108c
SS
85 return;
86 case SERIAL_EOF:
2acceee2 87 fputs_unfiltered ("<Eof>", stream);
c906108c
SS
88 return;
89 case SERIAL_BREAK:
2acceee2 90 fputs_unfiltered ("<Break>", stream);
c906108c
SS
91 return;
92 default:
93 if (serial_logbase == logbase_hex)
2acceee2 94 fprintf_unfiltered (stream, "%02x", ch & 0xff);
c906108c 95 else if (serial_logbase == logbase_octal)
2acceee2 96 fprintf_unfiltered (stream, "%03o", ch & 0xff);
c906108c
SS
97 else
98 switch (ch)
99 {
c5aa993b 100 case '\\':
2acceee2 101 fputs_unfiltered ("\\\\", stream);
c5aa993b
JM
102 break;
103 case '\b':
2acceee2 104 fputs_unfiltered ("\\b", stream);
c5aa993b
JM
105 break;
106 case '\f':
2acceee2 107 fputs_unfiltered ("\\f", stream);
c5aa993b
JM
108 break;
109 case '\n':
2acceee2 110 fputs_unfiltered ("\\n", stream);
c5aa993b
JM
111 break;
112 case '\r':
2acceee2 113 fputs_unfiltered ("\\r", stream);
c5aa993b
JM
114 break;
115 case '\t':
2acceee2 116 fputs_unfiltered ("\\t", stream);
c5aa993b
JM
117 break;
118 case '\v':
2acceee2 119 fputs_unfiltered ("\\v", stream);
c5aa993b
JM
120 break;
121 default:
3e43a32a
MS
122 fprintf_unfiltered (stream,
123 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
c5aa993b 124 break;
c906108c
SS
125 }
126 }
127}
128
129void
4ab76ea3 130serial_log_command (struct target_ops *self, const char *cmd)
c906108c
SS
131{
132 if (!serial_logfp)
133 return;
134
135 serial_current_type = 'c';
136
137 fputs_unfiltered ("\nc ", serial_logfp);
138 fputs_unfiltered (cmd, serial_logfp);
139
140 /* Make sure that the log file is as up-to-date as possible,
c378eb4e 141 in case we are getting ready to dump core or something. */
c906108c
SS
142 gdb_flush (serial_logfp);
143}
144
c2c6d25f 145\f
fcd488ca 146static const struct serial_ops *
58f07bae 147serial_interface_lookup (const char *name)
c906108c 148{
fcd488ca
TT
149 const struct serial_ops *ops;
150 int i;
c906108c 151
fcd488ca 152 for (i = 0; VEC_iterate (serial_ops_p, serial_ops_list, i, ops); ++i)
c906108c
SS
153 if (strcmp (name, ops->name) == 0)
154 return ops;
155
156 return NULL;
157}
158
159void
fcd488ca 160serial_add_interface (const struct serial_ops *optable)
c906108c 161{
fcd488ca 162 VEC_safe_push (serial_ops_p, serial_ops_list, optable);
c906108c
SS
163}
164
5eb3b062
PA
165/* Return the open serial device for FD, if found, or NULL if FD is
166 not already opened. */
167
168struct serial *
169serial_for_fd (int fd)
170{
171 struct serial *scb;
172
173 for (scb = scb_base; scb; scb = scb->next)
174 if (scb->fd == fd)
175 return scb;
176
177 return NULL;
178}
179
00340e1b
PA
180/* Create a new serial for OPS. */
181
182static struct serial *
183new_serial (const struct serial_ops *ops)
184{
185 struct serial *scb;
186
187 scb = XCNEW (struct serial);
188
189 scb->ops = ops;
190
191 scb->bufp = scb->buf;
192 scb->error_fd = -1;
193 scb->refcnt = 1;
194
195 return scb;
196}
197
198static struct serial *serial_open_ops_1 (const struct serial_ops *ops,
199 const char *open_name);
200
c378eb4e 201/* Open up a device or a network socket, depending upon the syntax of NAME. */
c906108c 202
819cc324 203struct serial *
c2c6d25f 204serial_open (const char *name)
c906108c 205{
819cc324 206 struct serial *scb;
fcd488ca 207 const struct serial_ops *ops;
c2c6d25f 208 const char *open_name = name;
c906108c 209
ca1ca08b 210 if (startswith (name, "|"))
c2c6d25f
JM
211 {
212 ops = serial_interface_lookup ("pipe");
8b9e3a15
VP
213 /* Discard ``|'' and any space before the command itself. */
214 ++open_name;
f1735a53 215 open_name = skip_spaces (open_name);
c2c6d25f 216 }
2821caf1
JB
217 /* Check for a colon, suggesting an IP address/port pair.
218 Do this *after* checking for all the interesting prefixes. We
219 don't want to constrain the syntax of what can follow them. */
220 else if (strchr (name, ':'))
221 ops = serial_interface_lookup ("tcp");
c906108c
SS
222 else
223 ops = serial_interface_lookup ("hardwire");
224
225 if (!ops)
226 return NULL;
227
00340e1b
PA
228 return serial_open_ops_1 (ops, open_name);
229}
c906108c 230
00340e1b 231/* Open up a serial for OPS, passing OPEN_NAME to the open method. */
c906108c 232
00340e1b
PA
233static struct serial *
234serial_open_ops_1 (const struct serial_ops *ops, const char *open_name)
235{
236 struct serial *scb;
237
238 scb = new_serial (ops);
c906108c 239
766062f6 240 /* `...->open (...)' would get expanded by the open(2) syscall macro. */
652aaa24 241 if ((*scb->ops->open) (scb, open_name))
c906108c 242 {
b8c9b27d 243 xfree (scb);
c906108c
SS
244 return NULL;
245 }
246
5eb3b062 247 scb->next = scb_base;
5eb3b062 248 scb_base = scb;
c906108c
SS
249
250 if (serial_logfile != NULL)
251 {
d7e74731
PA
252 stdio_file_up file (new stdio_file ());
253
254 if (!file->open (serial_logfile, "w"))
c906108c 255 perror_with_name (serial_logfile);
d7e74731
PA
256
257 serial_logfp = file.release ();
c906108c
SS
258 }
259
260 return scb;
261}
262
00340e1b
PA
263/* See serial.h. */
264
265struct serial *
266serial_open_ops (const struct serial_ops *ops)
267{
268 return serial_open_ops_1 (ops, NULL);
269}
270
58f07bae
PA
271/* Open a new serial stream using a file handle, using serial
272 interface ops OPS. */
273
274static struct serial *
fcd488ca 275serial_fdopen_ops (const int fd, const struct serial_ops *ops)
c906108c 276{
819cc324 277 struct serial *scb;
c906108c 278
0ea3f30e 279 if (!ops)
58f07bae
PA
280 {
281 ops = serial_interface_lookup ("terminal");
282 if (!ops)
283 ops = serial_interface_lookup ("hardwire");
284 }
c906108c
SS
285
286 if (!ops)
287 return NULL;
288
00340e1b 289 scb = new_serial (ops);
c906108c 290
5eb3b062 291 scb->next = scb_base;
5eb3b062 292 scb_base = scb;
c906108c 293
58f07bae
PA
294 if ((ops->fdopen) != NULL)
295 (*ops->fdopen) (scb, fd);
296 else
297 scb->fd = fd;
298
c906108c
SS
299 return scb;
300}
301
58f07bae
PA
302struct serial *
303serial_fdopen (const int fd)
304{
305 return serial_fdopen_ops (fd, NULL);
306}
307
c2c6d25f 308static void
819cc324 309do_serial_close (struct serial *scb, int really_close)
c906108c 310{
819cc324 311 struct serial *tmp_scb;
c906108c 312
c906108c
SS
313 if (serial_logfp)
314 {
315 fputs_unfiltered ("\nEnd of log\n", serial_logfp);
316 serial_current_type = 0;
317
c378eb4e 318 /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
d7e74731 319 delete serial_logfp;
c906108c
SS
320 serial_logfp = NULL;
321 }
322
c378eb4e 323 /* ensure that the FD has been taken out of async mode. */
c2c6d25f
JM
324 if (scb->async_handler != NULL)
325 serial_async (scb, NULL, NULL);
326
c906108c
SS
327 if (really_close)
328 scb->ops->close (scb);
329
ddefb60f
PA
330 /* For serial_is_open. */
331 scb->bufp = NULL;
332
5eb3b062
PA
333 if (scb_base == scb)
334 scb_base = scb_base->next;
335 else
336 for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
337 {
338 if (tmp_scb->next != scb)
339 continue;
340
341 tmp_scb->next = tmp_scb->next->next;
342 break;
343 }
344
ddefb60f 345 serial_unref (scb);
c906108c
SS
346}
347
c2c6d25f 348void
819cc324 349serial_close (struct serial *scb)
c2c6d25f
JM
350{
351 do_serial_close (scb, 1);
352}
353
354void
819cc324 355serial_un_fdopen (struct serial *scb)
c2c6d25f
JM
356{
357 do_serial_close (scb, 0);
358}
359
ddefb60f
PA
360int
361serial_is_open (struct serial *scb)
362{
363 return scb->bufp != NULL;
364}
365
366void
367serial_ref (struct serial *scb)
368{
369 scb->refcnt++;
370}
371
372void
373serial_unref (struct serial *scb)
374{
375 --scb->refcnt;
376 if (scb->refcnt == 0)
377 xfree (scb);
378}
379
c2c6d25f 380int
819cc324 381serial_readchar (struct serial *scb, int timeout)
c2c6d25f
JM
382{
383 int ch;
384
2df3850c 385 /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
c378eb4e 386 code is finished. */
2cd58942 387 if (0 && serial_is_async_p (scb) && timeout < 0)
8e65ff28 388 internal_error (__FILE__, __LINE__,
e2e0b3e5 389 _("serial_readchar: blocking read in async mode"));
2df3850c 390
c2c6d25f
JM
391 ch = scb->ops->readchar (scb, timeout);
392 if (serial_logfp != NULL)
393 {
2acceee2 394 serial_logchar (serial_logfp, 'r', ch, timeout);
c2c6d25f
JM
395
396 /* Make sure that the log file is as up-to-date as possible,
c378eb4e 397 in case we are getting ready to dump core or something. */
c2c6d25f
JM
398 gdb_flush (serial_logfp);
399 }
2cd58942 400 if (serial_debug_p (scb))
2acceee2
JM
401 {
402 fprintf_unfiltered (gdb_stdlog, "[");
403 serial_logchar (gdb_stdlog, 'r', ch, timeout);
404 fprintf_unfiltered (gdb_stdlog, "]");
405 gdb_flush (gdb_stdlog);
406 }
c2c6d25f
JM
407
408 return (ch);
409}
410
411int
c628b528 412serial_write (struct serial *scb, const void *buf, size_t count)
c2c6d25f
JM
413{
414 if (serial_logfp != NULL)
415 {
19ba03f4 416 const char *str = (const char *) buf;
c628b528 417 size_t c;
c2c6d25f 418
c628b528
PA
419 for (c = 0; c < count; c++)
420 serial_logchar (serial_logfp, 'w', str[c] & 0xff, 0);
c2c6d25f
JM
421
422 /* Make sure that the log file is as up-to-date as possible,
c378eb4e 423 in case we are getting ready to dump core or something. */
c2c6d25f
JM
424 gdb_flush (serial_logfp);
425 }
9214d371
DE
426 if (serial_debug_p (scb))
427 {
19ba03f4 428 const char *str = (const char *) buf;
c628b528 429 size_t c;
9214d371 430
c628b528 431 for (c = 0; c < count; c++)
9214d371
DE
432 {
433 fprintf_unfiltered (gdb_stdlog, "[");
0e58ee40 434 serial_logchar (gdb_stdlog, 'w', str[c] & 0xff, 0);
9214d371
DE
435 fprintf_unfiltered (gdb_stdlog, "]");
436 }
437 gdb_flush (gdb_stdlog);
438 }
c2c6d25f 439
c628b528 440 return (scb->ops->write (scb, buf, count));
c2c6d25f
JM
441}
442
443void
819cc324 444serial_printf (struct serial *desc, const char *format,...)
c2c6d25f
JM
445{
446 va_list args;
447 char *buf;
448 va_start (args, format);
449
e623b504 450 buf = xstrvprintf (format, args);
2cd58942 451 serial_write (desc, buf, strlen (buf));
c2c6d25f 452
b8c9b27d 453 xfree (buf);
c2c6d25f
JM
454 va_end (args);
455}
456
457int
819cc324 458serial_drain_output (struct serial *scb)
c2c6d25f
JM
459{
460 return scb->ops->drain_output (scb);
461}
462
463int
819cc324 464serial_flush_output (struct serial *scb)
c2c6d25f
JM
465{
466 return scb->ops->flush_output (scb);
467}
468
469int
819cc324 470serial_flush_input (struct serial *scb)
c2c6d25f
JM
471{
472 return scb->ops->flush_input (scb);
473}
474
475int
819cc324 476serial_send_break (struct serial *scb)
c2c6d25f
JM
477{
478 if (serial_logfp != NULL)
2acceee2 479 serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
c2c6d25f
JM
480
481 return (scb->ops->send_break (scb));
482}
483
484void
819cc324 485serial_raw (struct serial *scb)
c2c6d25f
JM
486{
487 scb->ops->go_raw (scb);
488}
489
490serial_ttystate
819cc324 491serial_get_tty_state (struct serial *scb)
c2c6d25f
JM
492{
493 return scb->ops->get_tty_state (scb);
494}
495
1e182ce8
UW
496serial_ttystate
497serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
498{
499 return scb->ops->copy_tty_state (scb, ttystate);
500}
501
c2c6d25f 502int
819cc324 503serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
c2c6d25f
JM
504{
505 return scb->ops->set_tty_state (scb, ttystate);
506}
507
508void
819cc324 509serial_print_tty_state (struct serial *scb,
c2c6d25f 510 serial_ttystate ttystate,
d9fcf2fb 511 struct ui_file *stream)
c2c6d25f
JM
512{
513 scb->ops->print_tty_state (scb, ttystate, stream);
514}
515
c2c6d25f 516int
819cc324 517serial_setbaudrate (struct serial *scb, int rate)
c2c6d25f
JM
518{
519 return scb->ops->setbaudrate (scb, rate);
520}
521
522int
819cc324 523serial_setstopbits (struct serial *scb, int num)
c2c6d25f
JM
524{
525 return scb->ops->setstopbits (scb, num);
526}
527
236af5e3
YG
528/* See serial.h. */
529
530int
531serial_setparity (struct serial *scb, int parity)
532{
533 return scb->ops->setparity (scb, parity);
534}
535
c2c6d25f 536int
819cc324 537serial_can_async_p (struct serial *scb)
c2c6d25f
JM
538{
539 return (scb->ops->async != NULL);
540}
541
542int
819cc324 543serial_is_async_p (struct serial *scb)
c2c6d25f
JM
544{
545 return (scb->ops->async != NULL) && (scb->async_handler != NULL);
546}
547
548void
819cc324 549serial_async (struct serial *scb,
c2c6d25f
JM
550 serial_event_ftype *handler,
551 void *context)
552{
05ce04a4 553 int changed = ((scb->async_handler == NULL) != (handler == NULL));
433759f7 554
c2c6d25f
JM
555 scb->async_handler = handler;
556 scb->async_context = context;
05ce04a4
VP
557 /* Only change mode if there is a need. */
558 if (changed)
559 scb->ops->async (scb, handler != NULL);
c2c6d25f
JM
560}
561
2acceee2 562void
819cc324 563serial_debug (struct serial *scb, int debug_p)
2acceee2
JM
564{
565 scb->debug_p = debug_p;
566}
567
568int
819cc324 569serial_debug_p (struct serial *scb)
2acceee2
JM
570{
571 return scb->debug_p || global_serial_debug_p;
572}
573
0ea3f30e
DJ
574#ifdef USE_WIN32API
575void
576serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
577{
578 if (scb->ops->wait_handle)
579 scb->ops->wait_handle (scb, read, except);
580 else
581 {
582 *read = (HANDLE) _get_osfhandle (scb->fd);
583 *except = NULL;
584 }
585}
c3e2b812
DJ
586
587void
588serial_done_wait_handle (struct serial *scb)
589{
590 if (scb->ops->done_wait_handle)
591 scb->ops->done_wait_handle (scb);
592}
0ea3f30e 593#endif
2acceee2 594
58f07bae
PA
595int
596serial_pipe (struct serial *scbs[2])
597{
fcd488ca 598 const struct serial_ops *ops;
58f07bae
PA
599 int fildes[2];
600
601 ops = serial_interface_lookup ("pipe");
602 if (!ops)
603 {
604 errno = ENOSYS;
605 return -1;
606 }
607
608 if (gdb_pipe (fildes) == -1)
609 return -1;
610
611 scbs[0] = serial_fdopen_ops (fildes[0], ops);
612 scbs[1] = serial_fdopen_ops (fildes[1], ops);
613 return 0;
614}
615
e3abfe1d
AC
616/* Serial set/show framework. */
617
618static struct cmd_list_element *serial_set_cmdlist;
619static struct cmd_list_element *serial_show_cmdlist;
620
621static void
981a3fb3 622serial_set_cmd (const char *args, int from_tty)
e3abfe1d 623{
3e43a32a
MS
624 printf_unfiltered ("\"set serial\" must be followed "
625 "by the name of a command.\n");
635c7e8a 626 help_list (serial_set_cmdlist, "set serial ", all_commands, gdb_stdout);
e3abfe1d
AC
627}
628
629static void
981a3fb3 630serial_show_cmd (const char *args, int from_tty)
e3abfe1d
AC
631{
632 cmd_show_list (serial_show_cmdlist, from_tty, "");
633}
634
0d12017b
JB
635/* Baud rate specified for talking to serial target systems. Default
636 is left as -1, so targets can choose their own defaults. */
637/* FIXME: This means that "show serial baud" and gr_files_info can
638 print -1 or (unsigned int)-1. This is a Bad User Interface. */
639
640int baud_rate = -1;
641
642static void
643serial_baud_show_cmd (struct ui_file *file, int from_tty,
644 struct cmd_list_element *c, const char *value)
645{
646 fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
647 value);
648}
e3abfe1d 649
236af5e3
YG
650/* Parity for serial port. */
651
652int serial_parity = GDBPARITY_NONE;
653
654static const char parity_none[] = "none";
655static const char parity_odd[] = "odd";
656static const char parity_even[] = "even";
657static const char *const parity_enums[] =
658 {parity_none, parity_odd, parity_even, NULL};
659static const char *parity = parity_none;
660
661/* Set serial_parity value. */
662
663static void
664set_parity (char *ignore_args, int from_tty, struct cmd_list_element *c)
665{
666 if (parity == parity_odd)
667 serial_parity = GDBPARITY_ODD;
668 else if (parity == parity_even)
669 serial_parity = GDBPARITY_EVEN;
670 else
671 serial_parity = GDBPARITY_NONE;
672}
673
c906108c 674void
c2c6d25f 675_initialize_serial (void)
c906108c
SS
676{
677#if 0
1bedd215
AC
678 add_com ("connect", class_obscure, connect_command, _("\
679Connect the terminal directly up to the command monitor.\n\
680Use <CR>~. or <CR>~^D to break out."));
c906108c
SS
681#endif /* 0 */
682
1bedd215
AC
683 add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
684Set default serial/parallel port configuration."),
e3abfe1d
AC
685 &serial_set_cmdlist, "set serial ",
686 0/*allow-unknown*/,
687 &setlist);
688
1bedd215
AC
689 add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
690Show default serial/parallel port configuration."),
e3abfe1d
AC
691 &serial_show_cmdlist, "show serial ",
692 0/*allow-unknown*/,
693 &showlist);
694
0d12017b
JB
695 /* If target is open when baud changes, it doesn't take effect until
696 the next open (I think, not sure). */
697 add_setshow_zinteger_cmd ("baud", no_class, &baud_rate, _("\
698Set baud rate for remote serial I/O."), _("\
699Show baud rate for remote serial I/O."), _("\
700This value is used to set the speed of the serial port when debugging\n\
701using remote targets."),
702 NULL,
703 serial_baud_show_cmd,
704 &serial_set_cmdlist, &serial_show_cmdlist);
705
236af5e3
YG
706 add_setshow_enum_cmd ("parity", no_class, parity_enums,
707 &parity, _("\
708Set parity for remote serial I/O"), _("\
709Show parity for remote serial I/O"), NULL,
710 set_parity,
711 NULL, /* FIXME: i18n: */
712 &serial_set_cmdlist, &serial_show_cmdlist);
713
f397e303
AC
714 add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
715Set filename for remote session recording."), _("\
716Show filename for remote session recording."), _("\
c906108c 717This file is used to record the remote session for future playback\n\
f397e303
AC
718by gdbserver."),
719 NULL,
720 NULL, /* FIXME: i18n: */
721 &setlist, &showlist);
c906108c 722
7ab04401
AC
723 add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
724 &serial_logbase, _("\
725Set numerical base for remote session logging"), _("\
726Show numerical base for remote session logging"), NULL,
727 NULL,
728 NULL, /* FIXME: i18n: */
729 &setlist, &showlist);
2acceee2 730
ccce17b0
YQ
731 add_setshow_zuinteger_cmd ("serial", class_maintenance,
732 &global_serial_debug_p, _("\
85c07804
AC
733Set serial debugging."), _("\
734Show serial debugging."), _("\
735When non-zero, serial port debugging is enabled."),
ccce17b0
YQ
736 NULL,
737 NULL, /* FIXME: i18n: */
738 &setdebuglist, &showdebuglist);
c906108c 739}