* tracepoint.c (print_one_static_tracepoint_marker): Constify.
[deliverable/binutils-gdb.git] / gdb / cli / cli-cmds.c
1 /* GDB CLI commands.
2
3 Copyright (C) 2000-2005, 2007-2012 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 3 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, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "exceptions.h"
22 #include "arch-utils.h"
23 #include "dyn-string.h"
24 #include "readline/readline.h"
25 #include "readline/tilde.h"
26 #include "completer.h"
27 #include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
28 #include "gdb_wait.h" /* For shell escape implementation. */
29 #include "gdb_regex.h" /* Used by apropos_command. */
30 #include "gdb_string.h"
31 #include "gdb_vfork.h"
32 #include "linespec.h"
33 #include "expression.h"
34 #include "frame.h"
35 #include "value.h"
36 #include "language.h"
37 #include "filenames.h" /* For DOSish file names. */
38 #include "objfiles.h"
39 #include "source.h"
40 #include "disasm.h"
41 #include "tracepoint.h"
42
43 #include "ui-out.h"
44
45 #include "top.h"
46 #include "cli/cli-decode.h"
47 #include "cli/cli-script.h"
48 #include "cli/cli-setshow.h"
49 #include "cli/cli-cmds.h"
50
51 #include "python/python.h"
52
53 #ifdef TUI
54 #include "tui/tui.h" /* For tui_active et.al. */
55 #endif
56
57 #include <fcntl.h>
58
59 /* Prototypes for local command functions */
60
61 static void complete_command (char *, int);
62
63 static void echo_command (char *, int);
64
65 static void pwd_command (char *, int);
66
67 static void show_version (char *, int);
68
69 static void help_command (char *, int);
70
71 static void show_command (char *, int);
72
73 static void info_command (char *, int);
74
75 static void show_debug (char *, int);
76
77 static void set_debug (char *, int);
78
79 static void show_user (char *, int);
80
81 static void make_command (char *, int);
82
83 static void shell_escape (char *, int);
84
85 static void edit_command (char *, int);
86
87 static void list_command (char *, int);
88
89 void apropos_command (char *, int);
90
91 /* Prototypes for local utility functions */
92
93 static void ambiguous_line_spec (struct symtabs_and_lines *);
94
95 static void filter_sals (struct symtabs_and_lines *);
96
97 \f
98 /* Limit the call depth of user-defined commands */
99 unsigned int max_user_call_depth;
100
101 /* Define all cmd_list_elements. */
102
103 /* Chain containing all defined commands. */
104
105 struct cmd_list_element *cmdlist;
106
107 /* Chain containing all defined info subcommands. */
108
109 struct cmd_list_element *infolist;
110
111 /* Chain containing all defined enable subcommands. */
112
113 struct cmd_list_element *enablelist;
114
115 /* Chain containing all defined disable subcommands. */
116
117 struct cmd_list_element *disablelist;
118
119 /* Chain containing all defined toggle subcommands. */
120
121 struct cmd_list_element *togglelist;
122
123 /* Chain containing all defined stop subcommands. */
124
125 struct cmd_list_element *stoplist;
126
127 /* Chain containing all defined delete subcommands. */
128
129 struct cmd_list_element *deletelist;
130
131 /* Chain containing all defined detach subcommands. */
132
133 struct cmd_list_element *detachlist;
134
135 /* Chain containing all defined kill subcommands. */
136
137 struct cmd_list_element *killlist;
138
139 /* Chain containing all defined set subcommands */
140
141 struct cmd_list_element *setlist;
142
143 /* Chain containing all defined unset subcommands */
144
145 struct cmd_list_element *unsetlist;
146
147 /* Chain containing all defined show subcommands. */
148
149 struct cmd_list_element *showlist;
150
151 /* Chain containing all defined \"set history\". */
152
153 struct cmd_list_element *sethistlist;
154
155 /* Chain containing all defined \"show history\". */
156
157 struct cmd_list_element *showhistlist;
158
159 /* Chain containing all defined \"unset history\". */
160
161 struct cmd_list_element *unsethistlist;
162
163 /* Chain containing all defined maintenance subcommands. */
164
165 struct cmd_list_element *maintenancelist;
166
167 /* Chain containing all defined "maintenance info" subcommands. */
168
169 struct cmd_list_element *maintenanceinfolist;
170
171 /* Chain containing all defined "maintenance print" subcommands. */
172
173 struct cmd_list_element *maintenanceprintlist;
174
175 struct cmd_list_element *setprintlist;
176
177 struct cmd_list_element *showprintlist;
178
179 struct cmd_list_element *setdebuglist;
180
181 struct cmd_list_element *showdebuglist;
182
183 struct cmd_list_element *setchecklist;
184
185 struct cmd_list_element *showchecklist;
186
187 /* Command tracing state. */
188
189 int source_verbose = 0;
190 int trace_commands = 0;
191 \f
192 /* 'script-extension' option support. */
193
194 static const char script_ext_off[] = "off";
195 static const char script_ext_soft[] = "soft";
196 static const char script_ext_strict[] = "strict";
197
198 static const char *const script_ext_enums[] = {
199 script_ext_off,
200 script_ext_soft,
201 script_ext_strict,
202 NULL
203 };
204
205 static const char *script_ext_mode = script_ext_soft;
206 \f
207 /* Utility used everywhere when at least one argument is needed and
208 none is supplied. */
209
210 void
211 error_no_arg (char *why)
212 {
213 error (_("Argument required (%s)."), why);
214 }
215
216 /* The "info" command is defined as a prefix, with allow_unknown = 0.
217 Therefore, its own definition is called only for "info" with no
218 args. */
219
220 static void
221 info_command (char *arg, int from_tty)
222 {
223 printf_unfiltered (_("\"info\" must be followed by "
224 "the name of an info command.\n"));
225 help_list (infolist, "info ", -1, gdb_stdout);
226 }
227
228 /* The "show" command with no arguments shows all the settings. */
229
230 static void
231 show_command (char *arg, int from_tty)
232 {
233 cmd_show_list (showlist, from_tty, "");
234 }
235 \f
236 /* Provide documentation on command or list given by COMMAND. FROM_TTY
237 is ignored. */
238
239 static void
240 help_command (char *command, int from_tty)
241 {
242 help_cmd (command, gdb_stdout);
243 }
244 \f
245 /* The "complete" command is used by Emacs to implement completion. */
246
247 static void
248 complete_command (char *arg, int from_tty)
249 {
250 int argpoint;
251 char *point, *arg_prefix;
252 VEC (char_ptr) *completions;
253
254 dont_repeat ();
255
256 if (arg == NULL)
257 arg = "";
258 argpoint = strlen (arg);
259
260 /* complete_line assumes that its first argument is somewhere
261 within, and except for filenames at the beginning of, the word to
262 be completed. The following crude imitation of readline's
263 word-breaking tries to accomodate this. */
264 point = arg + argpoint;
265 while (point > arg)
266 {
267 if (strchr (rl_completer_word_break_characters, point[-1]) != 0)
268 break;
269 point--;
270 }
271
272 arg_prefix = alloca (point - arg + 1);
273 memcpy (arg_prefix, arg, point - arg);
274 arg_prefix[point - arg] = 0;
275
276 completions = complete_line (point, arg, argpoint);
277
278 if (completions)
279 {
280 int ix, size = VEC_length (char_ptr, completions);
281 char *item, *prev = NULL;
282
283 qsort (VEC_address (char_ptr, completions), size,
284 sizeof (char *), compare_strings);
285
286 /* We do extra processing here since we only want to print each
287 unique item once. */
288 for (ix = 0; VEC_iterate (char_ptr, completions, ix, item); ++ix)
289 {
290 int next_item;
291
292 if (prev == NULL || strcmp (item, prev) != 0)
293 {
294 printf_unfiltered ("%s%s\n", arg_prefix, item);
295 xfree (prev);
296 prev = item;
297 }
298 else
299 xfree (item);
300 }
301
302 xfree (prev);
303 VEC_free (char_ptr, completions);
304 }
305 }
306
307 int
308 is_complete_command (struct cmd_list_element *c)
309 {
310 return cmd_cfunc_eq (c, complete_command);
311 }
312
313 static void
314 show_version (char *args, int from_tty)
315 {
316 print_gdb_version (gdb_stdout);
317 printf_filtered ("\n");
318 }
319
320 /* Handle the quit command. */
321
322 void
323 quit_command (char *args, int from_tty)
324 {
325 if (!quit_confirm ())
326 error (_("Not confirmed."));
327
328 disconnect_tracing (from_tty);
329
330 quit_force (args, from_tty);
331 }
332
333 static void
334 pwd_command (char *args, int from_tty)
335 {
336 if (args)
337 error (_("The \"pwd\" command does not take an argument: %s"), args);
338 if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
339 error (_("Error finding name of working directory: %s"),
340 safe_strerror (errno));
341
342 if (strcmp (gdb_dirbuf, current_directory) != 0)
343 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"),
344 current_directory, gdb_dirbuf);
345 else
346 printf_unfiltered (_("Working directory %s.\n"), current_directory);
347 }
348
349 void
350 cd_command (char *dir, int from_tty)
351 {
352 int len;
353 /* Found something other than leading repetitions of "/..". */
354 int found_real_path;
355 char *p;
356
357 /* If the new directory is absolute, repeat is a no-op; if relative,
358 repeat might be useful but is more likely to be a mistake. */
359 dont_repeat ();
360
361 if (dir == 0)
362 dir = "~";
363
364 dir = tilde_expand (dir);
365 make_cleanup (xfree, dir);
366
367 if (chdir (dir) < 0)
368 perror_with_name (dir);
369
370 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
371 /* There's too much mess with DOSish names like "d:", "d:.",
372 "d:./foo" etc. Instead of having lots of special #ifdef'ed code,
373 simply get the canonicalized name of the current directory. */
374 dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
375 #endif
376
377 len = strlen (dir);
378 if (IS_DIR_SEPARATOR (dir[len - 1]))
379 {
380 /* Remove the trailing slash unless this is a root directory
381 (including a drive letter on non-Unix systems). */
382 if (!(len == 1) /* "/" */
383 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
384 && !(len == 3 && dir[1] == ':') /* "d:/" */
385 #endif
386 )
387 len--;
388 }
389
390 dir = savestring (dir, len);
391 if (IS_ABSOLUTE_PATH (dir))
392 current_directory = dir;
393 else
394 {
395 if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1]))
396 current_directory = concat (current_directory, dir, (char *)NULL);
397 else
398 current_directory = concat (current_directory, SLASH_STRING,
399 dir, (char *)NULL);
400 xfree (dir);
401 }
402
403 /* Now simplify any occurrences of `.' and `..' in the pathname. */
404
405 found_real_path = 0;
406 for (p = current_directory; *p;)
407 {
408 if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
409 && (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
410 memmove (p, p + 2, strlen (p + 2) + 1);
411 else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
412 && (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
413 {
414 if (found_real_path)
415 {
416 /* Search backwards for the directory just before the "/.."
417 and obliterate it and the "/..". */
418 char *q = p;
419
420 while (q != current_directory && !IS_DIR_SEPARATOR (q[-1]))
421 --q;
422
423 if (q == current_directory)
424 /* current_directory is
425 a relative pathname ("can't happen"--leave it alone). */
426 ++p;
427 else
428 {
429 memmove (q - 1, p + 3, strlen (p + 3) + 1);
430 p = q - 1;
431 }
432 }
433 else
434 /* We are dealing with leading repetitions of "/..", for
435 example "/../..", which is the Mach super-root. */
436 p += 3;
437 }
438 else
439 {
440 found_real_path = 1;
441 ++p;
442 }
443 }
444
445 forget_cached_source_info ();
446
447 if (from_tty)
448 pwd_command ((char *) 0, 1);
449 }
450 \f
451 /* Show the current value of the 'script-extension' option. */
452
453 static void
454 show_script_ext_mode (struct ui_file *file, int from_tty,
455 struct cmd_list_element *c, const char *value)
456 {
457 fprintf_filtered (file,
458 _("Script filename extension recognition is \"%s\".\n"),
459 value);
460 }
461
462 /* Try to open SCRIPT_FILE.
463 If successful, the full path name is stored in *FULL_PATHP,
464 the stream is stored in *STREAMP, and return 1.
465 The caller is responsible for freeing *FULL_PATHP.
466 If not successful, return 0; errno is set for the last file
467 we tried to open.
468
469 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
470 search for it in the source search path.
471
472 NOTE: This calls openp which uses xfullpath to compute the full path
473 instead of gdb_realpath. Symbolic links are not resolved. */
474
475 int
476 find_and_open_script (const char *script_file, int search_path,
477 FILE **streamp, char **full_pathp)
478 {
479 char *file;
480 int fd;
481 struct cleanup *old_cleanups;
482 int search_flags = OPF_TRY_CWD_FIRST;
483
484 file = tilde_expand (script_file);
485 old_cleanups = make_cleanup (xfree, file);
486
487 if (search_path)
488 search_flags |= OPF_SEARCH_IN_PATH;
489
490 /* Search for and open 'file' on the search path used for source
491 files. Put the full location in *FULL_PATHP. */
492 fd = openp (source_path, search_flags,
493 file, O_RDONLY, full_pathp);
494
495 if (fd == -1)
496 {
497 int save_errno = errno;
498 do_cleanups (old_cleanups);
499 errno = save_errno;
500 return 0;
501 }
502
503 do_cleanups (old_cleanups);
504
505 *streamp = fdopen (fd, FOPEN_RT);
506 if (*streamp == NULL)
507 {
508 int save_errno = errno;
509
510 close (fd);
511 if (full_pathp)
512 xfree (*full_pathp);
513 errno = save_errno;
514 return 0;
515 }
516
517 return 1;
518 }
519
520 /* Load script FILE, which has already been opened as STREAM. */
521
522 static void
523 source_script_from_stream (FILE *stream, const char *file)
524 {
525 if (script_ext_mode != script_ext_off
526 && strlen (file) > 3 && !strcmp (&file[strlen (file) - 3], ".py"))
527 {
528 volatile struct gdb_exception e;
529
530 TRY_CATCH (e, RETURN_MASK_ERROR)
531 {
532 source_python_script (stream, file);
533 }
534 if (e.reason < 0)
535 {
536 /* Should we fallback to ye olde GDB script mode? */
537 if (script_ext_mode == script_ext_soft
538 && e.reason == RETURN_ERROR && e.error == UNSUPPORTED_ERROR)
539 {
540 fseek (stream, 0, SEEK_SET);
541 script_from_file (stream, (char*) file);
542 }
543 else
544 {
545 /* Nope, just punt. */
546 throw_exception (e);
547 }
548 }
549 }
550 else
551 script_from_file (stream, file);
552 }
553
554 /* Worker to perform the "source" command.
555 Load script FILE.
556 If SEARCH_PATH is non-zero, and the file isn't found in cwd,
557 search for it in the source search path. */
558
559 static void
560 source_script_with_search (const char *file, int from_tty, int search_path)
561 {
562 FILE *stream;
563 char *full_path;
564 struct cleanup *old_cleanups;
565
566 if (file == NULL || *file == 0)
567 error (_("source command requires file name of file to source."));
568
569 if (!find_and_open_script (file, search_path, &stream, &full_path))
570 {
571 /* The script wasn't found, or was otherwise inaccessible.
572 If the source command was invoked interactively, throw an
573 error. Otherwise (e.g. if it was invoked by a script),
574 silently ignore the error. */
575 if (from_tty)
576 perror_with_name (file);
577 else
578 return;
579 }
580
581 old_cleanups = make_cleanup (xfree, full_path);
582 make_cleanup_fclose (stream);
583 /* The python support reopens the file, so we need to pass full_path here
584 in case the file was found on the search path. It's useful to do this
585 anyway so that error messages show the actual file used. But only do
586 this if we (may have) used search_path, as printing the full path in
587 errors for the non-search case can be more noise than signal. */
588 source_script_from_stream (stream, search_path ? full_path : file);
589 do_cleanups (old_cleanups);
590 }
591
592 /* Wrapper around source_script_with_search to export it to main.c
593 for use in loading .gdbinit scripts. */
594
595 void
596 source_script (char *file, int from_tty)
597 {
598 source_script_with_search (file, from_tty, 0);
599 }
600
601 /* Return the source_verbose global variable to its previous state
602 on exit from the source command, by whatever means. */
603 static void
604 source_verbose_cleanup (void *old_value)
605 {
606 source_verbose = *(int *)old_value;
607 xfree (old_value);
608 }
609
610 static void
611 source_command (char *args, int from_tty)
612 {
613 struct cleanup *old_cleanups;
614 char *file = args;
615 int *old_source_verbose = xmalloc (sizeof(int));
616 int search_path = 0;
617
618 *old_source_verbose = source_verbose;
619 old_cleanups = make_cleanup (source_verbose_cleanup,
620 old_source_verbose);
621
622 /* -v causes the source command to run in verbose mode.
623 -s causes the file to be searched in the source search path,
624 even if the file name contains a '/'.
625 We still have to be able to handle filenames with spaces in a
626 backward compatible way, so buildargv is not appropriate. */
627
628 if (args)
629 {
630 while (args[0] != '\0')
631 {
632 /* Make sure leading white space does not break the
633 comparisons. */
634 while (isspace(args[0]))
635 args++;
636
637 if (args[0] != '-')
638 break;
639
640 if (args[1] == 'v' && isspace (args[2]))
641 {
642 source_verbose = 1;
643
644 /* Skip passed -v. */
645 args = &args[3];
646 }
647 else if (args[1] == 's' && isspace (args[2]))
648 {
649 search_path = 1;
650
651 /* Skip passed -s. */
652 args = &args[3];
653 }
654 else
655 break;
656 }
657
658 while (isspace (args[0]))
659 args++;
660 file = args;
661 }
662
663 source_script_with_search (file, from_tty, search_path);
664
665 do_cleanups (old_cleanups);
666 }
667
668
669 static void
670 echo_command (char *text, int from_tty)
671 {
672 char *p = text;
673 int c;
674
675 if (text)
676 while ((c = *p++) != '\0')
677 {
678 if (c == '\\')
679 {
680 /* \ at end of argument is used after spaces
681 so they won't be lost. */
682 if (*p == 0)
683 return;
684
685 c = parse_escape (get_current_arch (), &p);
686 if (c >= 0)
687 printf_filtered ("%c", c);
688 }
689 else
690 printf_filtered ("%c", c);
691 }
692
693 /* Force this output to appear now. */
694 wrap_here ("");
695 gdb_flush (gdb_stdout);
696 }
697
698 static void
699 shell_escape (char *arg, int from_tty)
700 {
701 #if defined(CANT_FORK) || \
702 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
703 /* If ARG is NULL, they want an inferior shell, but `system' just
704 reports if the shell is available when passed a NULL arg. */
705 int rc = system (arg ? arg : "");
706
707 if (!arg)
708 arg = "inferior shell";
709
710 if (rc == -1)
711 {
712 fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
713 safe_strerror (errno));
714 gdb_flush (gdb_stderr);
715 }
716 else if (rc)
717 {
718 fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
719 gdb_flush (gdb_stderr);
720 }
721 #ifdef GLOBAL_CURDIR
722 /* Make sure to return to the directory GDB thinks it is, in case
723 the shell command we just ran changed it. */
724 chdir (current_directory);
725 #endif
726 #else /* Can fork. */
727 int status, pid;
728
729 if ((pid = vfork ()) == 0)
730 {
731 const char *p, *user_shell;
732
733 if ((user_shell = (char *) getenv ("SHELL")) == NULL)
734 user_shell = "/bin/sh";
735
736 /* Get the name of the shell for arg0. */
737 p = lbasename (user_shell);
738
739 if (!arg)
740 execl (user_shell, p, (char *) 0);
741 else
742 execl (user_shell, p, "-c", arg, (char *) 0);
743
744 fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
745 safe_strerror (errno));
746 gdb_flush (gdb_stderr);
747 _exit (0177);
748 }
749
750 if (pid != -1)
751 waitpid (pid, &status, 0);
752 else
753 error (_("Fork failed"));
754 #endif /* Can fork. */
755 }
756
757 static void
758 edit_command (char *arg, int from_tty)
759 {
760 struct symtabs_and_lines sals;
761 struct symtab_and_line sal;
762 struct symbol *sym;
763 char *arg1;
764 char *editor;
765 char *p;
766 const char *fn;
767
768 /* Pull in the current default source line if necessary. */
769 if (arg == 0)
770 {
771 set_default_source_symtab_and_line ();
772 sal = get_current_source_symtab_and_line ();
773 }
774
775 /* Bare "edit" edits file with present line. */
776
777 if (arg == 0)
778 {
779 if (sal.symtab == 0)
780 error (_("No default source file yet."));
781 sal.line += get_lines_to_list () / 2;
782 }
783 else
784 {
785 /* Now should only be one argument -- decode it in SAL. */
786
787 arg1 = arg;
788 sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
789
790 filter_sals (&sals);
791 if (! sals.nelts)
792 {
793 /* C++ */
794 return;
795 }
796 if (sals.nelts > 1)
797 {
798 ambiguous_line_spec (&sals);
799 xfree (sals.sals);
800 return;
801 }
802
803 sal = sals.sals[0];
804 xfree (sals.sals);
805
806 if (*arg1)
807 error (_("Junk at end of line specification."));
808
809 /* If line was specified by address, first print exactly which
810 line, and which file. In this case, sal.symtab == 0 means
811 address is outside of all known source files, not that user
812 failed to give a filename. */
813 if (*arg == '*')
814 {
815 struct gdbarch *gdbarch;
816
817 if (sal.symtab == 0)
818 /* FIXME-32x64--assumes sal.pc fits in long. */
819 error (_("No source file for address %s."),
820 hex_string ((unsigned long) sal.pc));
821
822 gdbarch = get_objfile_arch (sal.symtab->objfile);
823 sym = find_pc_function (sal.pc);
824 if (sym)
825 printf_filtered ("%s is in %s (%s:%d).\n",
826 paddress (gdbarch, sal.pc),
827 SYMBOL_PRINT_NAME (sym),
828 sal.symtab->filename, sal.line);
829 else
830 printf_filtered ("%s is at %s:%d.\n",
831 paddress (gdbarch, sal.pc),
832 sal.symtab->filename, sal.line);
833 }
834
835 /* If what was given does not imply a symtab, it must be an
836 undebuggable symbol which means no source code. */
837
838 if (sal.symtab == 0)
839 error (_("No line number known for %s."), arg);
840 }
841
842 if ((editor = (char *) getenv ("EDITOR")) == NULL)
843 editor = "/bin/ex";
844
845 /* If we don't already know the full absolute file name of the
846 source file, find it now. */
847 if (!sal.symtab->fullname)
848 {
849 fn = symtab_to_fullname (sal.symtab);
850 if (!fn)
851 fn = "unknown";
852 }
853 else
854 fn = sal.symtab->fullname;
855
856 /* Quote the file name, in case it has whitespace or other special
857 characters. */
858 p = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
859 shell_escape (p, from_tty);
860 xfree (p);
861 }
862
863 static void
864 list_command (char *arg, int from_tty)
865 {
866 struct symtabs_and_lines sals, sals_end;
867 struct symtab_and_line sal = { 0 };
868 struct symtab_and_line sal_end = { 0 };
869 struct symtab_and_line cursal = { 0 };
870 struct symbol *sym;
871 char *arg1;
872 int no_end = 1;
873 int dummy_end = 0;
874 int dummy_beg = 0;
875 int linenum_beg = 0;
876 char *p;
877
878 /* Pull in the current default source line if necessary. */
879 if (arg == 0 || arg[0] == '+' || arg[0] == '-')
880 {
881 set_default_source_symtab_and_line ();
882 cursal = get_current_source_symtab_and_line ();
883 }
884
885 /* "l" or "l +" lists next ten lines. */
886
887 if (arg == 0 || strcmp (arg, "+") == 0)
888 {
889 print_source_lines (cursal.symtab, cursal.line,
890 cursal.line + get_lines_to_list (), 0);
891 return;
892 }
893
894 /* "l -" lists previous ten lines, the ones before the ten just
895 listed. */
896 if (strcmp (arg, "-") == 0)
897 {
898 print_source_lines (cursal.symtab,
899 max (get_first_line_listed ()
900 - get_lines_to_list (), 1),
901 get_first_line_listed (), 0);
902 return;
903 }
904
905 /* Now if there is only one argument, decode it in SAL
906 and set NO_END.
907 If there are two arguments, decode them in SAL and SAL_END
908 and clear NO_END; however, if one of the arguments is blank,
909 set DUMMY_BEG or DUMMY_END to record that fact. */
910
911 if (!have_full_symbols () && !have_partial_symbols ())
912 error (_("No symbol table is loaded. Use the \"file\" command."));
913
914 arg1 = arg;
915 if (*arg1 == ',')
916 dummy_beg = 1;
917 else
918 {
919 sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
920
921 filter_sals (&sals);
922 if (!sals.nelts)
923 return; /* C++ */
924 if (sals.nelts > 1)
925 {
926 ambiguous_line_spec (&sals);
927 xfree (sals.sals);
928 return;
929 }
930
931 sal = sals.sals[0];
932 xfree (sals.sals);
933 }
934
935 /* Record whether the BEG arg is all digits. */
936
937 for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
938 linenum_beg = (p == arg1);
939
940 while (*arg1 == ' ' || *arg1 == '\t')
941 arg1++;
942 if (*arg1 == ',')
943 {
944 no_end = 0;
945 arg1++;
946 while (*arg1 == ' ' || *arg1 == '\t')
947 arg1++;
948 if (*arg1 == 0)
949 dummy_end = 1;
950 else
951 {
952 if (dummy_beg)
953 sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
954 else
955 sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE,
956 sal.symtab, sal.line);
957 filter_sals (&sals_end);
958 if (sals_end.nelts == 0)
959 return;
960 if (sals_end.nelts > 1)
961 {
962 ambiguous_line_spec (&sals_end);
963 xfree (sals_end.sals);
964 return;
965 }
966 sal_end = sals_end.sals[0];
967 xfree (sals_end.sals);
968 }
969 }
970
971 if (*arg1)
972 error (_("Junk at end of line specification."));
973
974 if (!no_end && !dummy_beg && !dummy_end
975 && sal.symtab != sal_end.symtab)
976 error (_("Specified start and end are in different files."));
977 if (dummy_beg && dummy_end)
978 error (_("Two empty args do not say what lines to list."));
979
980 /* If line was specified by address,
981 first print exactly which line, and which file.
982
983 In this case, sal.symtab == 0 means address is outside of all
984 known source files, not that user failed to give a filename. */
985 if (*arg == '*')
986 {
987 struct gdbarch *gdbarch;
988
989 if (sal.symtab == 0)
990 /* FIXME-32x64--assumes sal.pc fits in long. */
991 error (_("No source file for address %s."),
992 hex_string ((unsigned long) sal.pc));
993
994 gdbarch = get_objfile_arch (sal.symtab->objfile);
995 sym = find_pc_function (sal.pc);
996 if (sym)
997 printf_filtered ("%s is in %s (%s:%d).\n",
998 paddress (gdbarch, sal.pc),
999 SYMBOL_PRINT_NAME (sym),
1000 sal.symtab->filename, sal.line);
1001 else
1002 printf_filtered ("%s is at %s:%d.\n",
1003 paddress (gdbarch, sal.pc),
1004 sal.symtab->filename, sal.line);
1005 }
1006
1007 /* If line was not specified by just a line number, and it does not
1008 imply a symtab, it must be an undebuggable symbol which means no
1009 source code. */
1010
1011 if (!linenum_beg && sal.symtab == 0)
1012 error (_("No line number known for %s."), arg);
1013
1014 /* If this command is repeated with RET,
1015 turn it into the no-arg variant. */
1016
1017 if (from_tty)
1018 *arg = 0;
1019
1020 if (dummy_beg && sal_end.symtab == 0)
1021 error (_("No default source file yet. Do \"help list\"."));
1022 if (dummy_beg)
1023 print_source_lines (sal_end.symtab,
1024 max (sal_end.line - (get_lines_to_list () - 1), 1),
1025 sal_end.line + 1, 0);
1026 else if (sal.symtab == 0)
1027 error (_("No default source file yet. Do \"help list\"."));
1028 else if (no_end)
1029 {
1030 int first_line = sal.line - get_lines_to_list () / 2;
1031
1032 if (first_line < 1) first_line = 1;
1033
1034 print_source_lines (sal.symtab,
1035 first_line,
1036 first_line + get_lines_to_list (),
1037 0);
1038 }
1039 else
1040 print_source_lines (sal.symtab, sal.line,
1041 (dummy_end
1042 ? sal.line + get_lines_to_list ()
1043 : sal_end.line + 1),
1044 0);
1045 }
1046
1047 /* Subroutine of disassemble_command to simplify it.
1048 Perform the disassembly.
1049 NAME is the name of the function if known, or NULL.
1050 [LOW,HIGH) are the range of addresses to disassemble.
1051 MIXED is non-zero to print source with the assembler. */
1052
1053 static void
1054 print_disassembly (struct gdbarch *gdbarch, const char *name,
1055 CORE_ADDR low, CORE_ADDR high, int flags)
1056 {
1057 #if defined(TUI)
1058 if (!tui_is_window_visible (DISASSEM_WIN))
1059 #endif
1060 {
1061 printf_filtered ("Dump of assembler code ");
1062 if (name != NULL)
1063 printf_filtered ("for function %s:\n", name);
1064 else
1065 printf_filtered ("from %s to %s:\n",
1066 paddress (gdbarch, low), paddress (gdbarch, high));
1067
1068 /* Dump the specified range. */
1069 gdb_disassembly (gdbarch, current_uiout, 0, flags, -1, low, high);
1070
1071 printf_filtered ("End of assembler dump.\n");
1072 gdb_flush (gdb_stdout);
1073 }
1074 #if defined(TUI)
1075 else
1076 {
1077 tui_show_assembly (gdbarch, low);
1078 }
1079 #endif
1080 }
1081
1082 /* Subroutine of disassemble_command to simplify it.
1083 Print a disassembly of the current function according to FLAGS. */
1084
1085 static void
1086 disassemble_current_function (int flags)
1087 {
1088 struct frame_info *frame;
1089 struct gdbarch *gdbarch;
1090 CORE_ADDR low, high, pc;
1091 const char *name;
1092
1093 frame = get_selected_frame (_("No frame selected."));
1094 gdbarch = get_frame_arch (frame);
1095 pc = get_frame_address_in_block (frame);
1096 if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1097 error (_("No function contains program counter for selected frame."));
1098 #if defined(TUI)
1099 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1100 `tui_version'. */
1101 if (tui_active)
1102 /* FIXME: cagney/2004-02-07: This should be an observer. */
1103 low = tui_get_low_disassembly_address (gdbarch, low, pc);
1104 #endif
1105 low += gdbarch_deprecated_function_start_offset (gdbarch);
1106
1107 print_disassembly (gdbarch, name, low, high, flags);
1108 }
1109
1110 /* Dump a specified section of assembly code.
1111
1112 Usage:
1113 disassemble [/mr]
1114 - dump the assembly code for the function of the current pc
1115 disassemble [/mr] addr
1116 - dump the assembly code for the function at ADDR
1117 disassemble [/mr] low,high
1118 disassemble [/mr] low,+length
1119 - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1120
1121 A /m modifier will include source code with the assembly.
1122 A /r modifier will include raw instructions in hex with the assembly. */
1123
1124 static void
1125 disassemble_command (char *arg, int from_tty)
1126 {
1127 struct gdbarch *gdbarch = get_current_arch ();
1128 CORE_ADDR low, high;
1129 const char *name;
1130 CORE_ADDR pc;
1131 int flags;
1132
1133 name = NULL;
1134 flags = 0;
1135
1136 if (arg && *arg == '/')
1137 {
1138 ++arg;
1139
1140 if (*arg == '\0')
1141 error (_("Missing modifier."));
1142
1143 while (*arg && ! isspace (*arg))
1144 {
1145 switch (*arg++)
1146 {
1147 case 'm':
1148 flags |= DISASSEMBLY_SOURCE;
1149 break;
1150 case 'r':
1151 flags |= DISASSEMBLY_RAW_INSN;
1152 break;
1153 default:
1154 error (_("Invalid disassembly modifier."));
1155 }
1156 }
1157
1158 while (isspace (*arg))
1159 ++arg;
1160 }
1161
1162 if (! arg || ! *arg)
1163 {
1164 flags |= DISASSEMBLY_OMIT_FNAME;
1165 disassemble_current_function (flags);
1166 return;
1167 }
1168
1169 pc = value_as_address (parse_to_comma_and_eval (&arg));
1170 if (arg[0] == ',')
1171 ++arg;
1172 if (arg[0] == '\0')
1173 {
1174 /* One argument. */
1175 if (find_pc_partial_function (pc, &name, &low, &high) == 0)
1176 error (_("No function contains specified address."));
1177 #if defined(TUI)
1178 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1179 `tui_version'. */
1180 if (tui_active)
1181 /* FIXME: cagney/2004-02-07: This should be an observer. */
1182 low = tui_get_low_disassembly_address (gdbarch, low, pc);
1183 #endif
1184 low += gdbarch_deprecated_function_start_offset (gdbarch);
1185 flags |= DISASSEMBLY_OMIT_FNAME;
1186 }
1187 else
1188 {
1189 /* Two arguments. */
1190 int incl_flag = 0;
1191 low = pc;
1192 while (isspace (*arg))
1193 arg++;
1194 if (arg[0] == '+')
1195 {
1196 ++arg;
1197 incl_flag = 1;
1198 }
1199 high = parse_and_eval_address (arg);
1200 if (incl_flag)
1201 high += low;
1202 }
1203
1204 print_disassembly (gdbarch, name, low, high, flags);
1205 }
1206
1207 static void
1208 make_command (char *arg, int from_tty)
1209 {
1210 char *p;
1211
1212 if (arg == 0)
1213 p = "make";
1214 else
1215 {
1216 p = xmalloc (sizeof ("make ") + strlen (arg));
1217 strcpy (p, "make ");
1218 strcpy (p + sizeof ("make ") - 1, arg);
1219 }
1220
1221 shell_escape (p, from_tty);
1222 }
1223
1224 static void
1225 show_user (char *args, int from_tty)
1226 {
1227 struct cmd_list_element *c;
1228 extern struct cmd_list_element *cmdlist;
1229
1230 if (args)
1231 {
1232 char *comname = args;
1233
1234 c = lookup_cmd (&comname, cmdlist, "", 0, 1);
1235 /* c->user_commands would be NULL if it's a python command. */
1236 if (c->class != class_user || !c->user_commands)
1237 error (_("Not a user command."));
1238 show_user_1 (c, "", args, gdb_stdout);
1239 }
1240 else
1241 {
1242 for (c = cmdlist; c; c = c->next)
1243 {
1244 if (c->class == class_user || c->prefixlist != NULL)
1245 show_user_1 (c, "", c->name, gdb_stdout);
1246 }
1247 }
1248 }
1249
1250 /* Search through names of commands and documentations for a certain
1251 regular expression. */
1252
1253 void
1254 apropos_command (char *searchstr, int from_tty)
1255 {
1256 regex_t pattern;
1257 int code;
1258
1259 if (searchstr == NULL)
1260 error (_("REGEXP string is empty"));
1261
1262 code = regcomp (&pattern, searchstr, REG_ICASE);
1263 if (code == 0)
1264 {
1265 struct cleanup *cleanups;
1266
1267 cleanups = make_regfree_cleanup (&pattern);
1268 apropos_cmd (gdb_stdout, cmdlist, &pattern, "");
1269 do_cleanups (cleanups);
1270 }
1271 else
1272 {
1273 char *err = get_regcomp_error (code, &pattern);
1274
1275 make_cleanup (xfree, err);
1276 error (_("Error in regular expression: %s"), err);
1277 }
1278 }
1279
1280 /* Subroutine of alias_command to simplify it.
1281 Return the first N elements of ARGV flattened back to a string
1282 with a space separating each element.
1283 ARGV may not be NULL.
1284 This does not take care of quoting elements in case they contain spaces
1285 on purpose. */
1286
1287 static dyn_string_t
1288 argv_to_dyn_string (char **argv, int n)
1289 {
1290 int i;
1291 dyn_string_t result = dyn_string_new (10);
1292
1293 gdb_assert (argv != NULL);
1294 gdb_assert (n >= 0 && n <= countargv (argv));
1295
1296 for (i = 0; i < n; ++i)
1297 {
1298 if (i > 0)
1299 dyn_string_append_char (result, ' ');
1300 dyn_string_append_cstr (result, argv[i]);
1301 }
1302
1303 return result;
1304 }
1305
1306 /* Subroutine of alias_command to simplify it.
1307 Return TRUE if COMMAND exists, unambiguously. Otherwise FALSE. */
1308
1309 static int
1310 valid_command_p (char *command)
1311 {
1312 struct cmd_list_element *c;
1313
1314 c = lookup_cmd_1 (& command, cmdlist, NULL, 1);
1315
1316 if (c == NULL || c == (struct cmd_list_element *) -1)
1317 return FALSE;
1318
1319 /* This is the slightly tricky part.
1320 lookup_cmd_1 will return a pointer to the last part of COMMAND
1321 to match, leaving COMMAND pointing at the remainder. */
1322 while (*command == ' ' || *command == '\t')
1323 ++command;
1324 return *command == '\0';
1325 }
1326
1327 /* Make an alias of an existing command. */
1328
1329 static void
1330 alias_command (char *args, int from_tty)
1331 {
1332 int i, alias_argc, command_argc;
1333 int abbrev_flag = 0;
1334 char *args2, *equals, *alias, *command;
1335 char **alias_argv, **command_argv;
1336 dyn_string_t alias_dyn_string, command_dyn_string;
1337 struct cmd_list_element *c;
1338 static const char usage[] = N_("Usage: alias [-a] [--] ALIAS = COMMAND");
1339
1340 if (args == NULL || strchr (args, '=') == NULL)
1341 error (_(usage));
1342
1343 args2 = xstrdup (args);
1344 make_cleanup (xfree, args2);
1345 equals = strchr (args2, '=');
1346 *equals = '\0';
1347 alias_argv = gdb_buildargv (args2);
1348 make_cleanup_freeargv (alias_argv);
1349 command_argv = gdb_buildargv (equals + 1);
1350 make_cleanup_freeargv (command_argv);
1351
1352 for (i = 0; alias_argv[i] != NULL; )
1353 {
1354 if (strcmp (alias_argv[i], "-a") == 0)
1355 {
1356 ++alias_argv;
1357 abbrev_flag = 1;
1358 }
1359 else if (strcmp (alias_argv[i], "--") == 0)
1360 {
1361 ++alias_argv;
1362 break;
1363 }
1364 else
1365 break;
1366 }
1367
1368 if (alias_argv[0] == NULL || command_argv[0] == NULL
1369 || *alias_argv[0] == '\0' || *command_argv[0] == '\0')
1370 error (_(usage));
1371
1372 for (i = 0; alias_argv[i] != NULL; ++i)
1373 {
1374 if (! valid_user_defined_cmd_name_p (alias_argv[i]))
1375 {
1376 if (i == 0)
1377 error (_("Invalid command name: %s"), alias_argv[i]);
1378 else
1379 error (_("Invalid command element name: %s"), alias_argv[i]);
1380 }
1381 }
1382
1383 alias_argc = countargv (alias_argv);
1384 command_argc = countargv (command_argv);
1385
1386 /* COMMAND must exist.
1387 Reconstruct the command to remove any extraneous spaces,
1388 for better error messages. */
1389 command_dyn_string = argv_to_dyn_string (command_argv, command_argc);
1390 make_cleanup_dyn_string_delete (command_dyn_string);
1391 command = dyn_string_buf (command_dyn_string);
1392 if (! valid_command_p (command))
1393 error (_("Invalid command to alias to: %s"), command);
1394
1395 /* ALIAS must not exist. */
1396 alias_dyn_string = argv_to_dyn_string (alias_argv, alias_argc);
1397 make_cleanup_dyn_string_delete (alias_dyn_string);
1398 alias = dyn_string_buf (alias_dyn_string);
1399 if (valid_command_p (alias))
1400 error (_("Alias already exists: %s"), alias);
1401
1402 /* If ALIAS is one word, it is an alias for the entire COMMAND.
1403 Example: alias spe = set print elements
1404
1405 Otherwise ALIAS and COMMAND must have the same number of words,
1406 and every word except the last must match; and the last word of
1407 ALIAS is made an alias of the last word of COMMAND.
1408 Example: alias set print elms = set pr elem
1409 Note that unambiguous abbreviations are allowed. */
1410
1411 if (alias_argc == 1)
1412 {
1413 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1414 add_com_alias (xstrdup (alias_argv[0]), command, class_alias,
1415 abbrev_flag);
1416 }
1417 else
1418 {
1419 dyn_string_t alias_prefix_dyn_string, command_prefix_dyn_string;
1420 char *alias_prefix, *command_prefix;
1421 struct cmd_list_element *c_alias, *c_command;
1422
1423 if (alias_argc != command_argc)
1424 error (_("Mismatched command length between ALIAS and COMMAND."));
1425
1426 /* Create copies of ALIAS and COMMAND without the last word,
1427 and use that to verify the leading elements match. */
1428 alias_prefix_dyn_string =
1429 argv_to_dyn_string (alias_argv, alias_argc - 1);
1430 make_cleanup_dyn_string_delete (alias_prefix_dyn_string);
1431 command_prefix_dyn_string =
1432 argv_to_dyn_string (alias_argv, command_argc - 1);
1433 make_cleanup_dyn_string_delete (command_prefix_dyn_string);
1434 alias_prefix = dyn_string_buf (alias_prefix_dyn_string);
1435 command_prefix = dyn_string_buf (command_prefix_dyn_string);
1436
1437 c_command = lookup_cmd_1 (& command_prefix, cmdlist, NULL, 1);
1438 /* We've already tried to look up COMMAND. */
1439 gdb_assert (c_command != NULL
1440 && c_command != (struct cmd_list_element *) -1);
1441 gdb_assert (c_command->prefixlist != NULL);
1442 c_alias = lookup_cmd_1 (& alias_prefix, cmdlist, NULL, 1);
1443 if (c_alias != c_command)
1444 error (_("ALIAS and COMMAND prefixes do not match."));
1445
1446 /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
1447 add_alias_cmd (xstrdup (alias_argv[alias_argc - 1]),
1448 command_argv[command_argc - 1],
1449 class_alias, abbrev_flag, c_command->prefixlist);
1450 }
1451 }
1452 \f
1453 /* Print a list of files and line numbers which a user may choose from
1454 in order to list a function which was specified ambiguously (as
1455 with `list classname::overloadedfuncname', for example). The
1456 vector in SALS provides the filenames and line numbers. */
1457
1458 static void
1459 ambiguous_line_spec (struct symtabs_and_lines *sals)
1460 {
1461 int i;
1462
1463 for (i = 0; i < sals->nelts; ++i)
1464 printf_filtered (_("file: \"%s\", line number: %d\n"),
1465 sals->sals[i].symtab->filename, sals->sals[i].line);
1466 }
1467
1468 /* Sort function for filter_sals. */
1469
1470 static int
1471 compare_symtabs (const void *a, const void *b)
1472 {
1473 const struct symtab_and_line *sala = a;
1474 const struct symtab_and_line *salb = b;
1475 int r;
1476
1477 if (!sala->symtab->dirname)
1478 {
1479 if (salb->symtab->dirname)
1480 return -1;
1481 }
1482 else if (!salb->symtab->dirname)
1483 {
1484 if (sala->symtab->dirname)
1485 return 1;
1486 }
1487 else
1488 {
1489 r = filename_cmp (sala->symtab->dirname, salb->symtab->dirname);
1490 if (r)
1491 return r;
1492 }
1493
1494 r = filename_cmp (sala->symtab->filename, salb->symtab->filename);
1495 if (r)
1496 return r;
1497
1498 if (sala->line < salb->line)
1499 return -1;
1500 return sala->line == salb->line ? 0 : 1;
1501 }
1502
1503 /* Remove any SALs that do not match the current program space, or
1504 which appear to be "file:line" duplicates. */
1505
1506 static void
1507 filter_sals (struct symtabs_and_lines *sals)
1508 {
1509 int i, out, prev;
1510
1511 out = 0;
1512 for (i = 0; i < sals->nelts; ++i)
1513 {
1514 if (sals->sals[i].pspace == current_program_space
1515 && sals->sals[i].symtab != NULL)
1516 {
1517 sals->sals[out] = sals->sals[i];
1518 ++out;
1519 }
1520 }
1521 sals->nelts = out;
1522
1523 qsort (sals->sals, sals->nelts, sizeof (struct symtab_and_line),
1524 compare_symtabs);
1525
1526 out = 1;
1527 prev = 0;
1528 for (i = 1; i < sals->nelts; ++i)
1529 {
1530 if (compare_symtabs (&sals->sals[prev], &sals->sals[i]))
1531 {
1532 /* Symtabs differ. */
1533 sals->sals[out] = sals->sals[i];
1534 prev = out;
1535 ++out;
1536 }
1537 }
1538
1539 if (sals->nelts == 0)
1540 {
1541 xfree (sals->sals);
1542 sals->sals = NULL;
1543 }
1544 else
1545 sals->nelts = out;
1546 }
1547
1548 static void
1549 set_debug (char *arg, int from_tty)
1550 {
1551 printf_unfiltered (_("\"set debug\" must be followed by "
1552 "the name of a debug subcommand.\n"));
1553 help_list (setdebuglist, "set debug ", -1, gdb_stdout);
1554 }
1555
1556 static void
1557 show_debug (char *args, int from_tty)
1558 {
1559 cmd_show_list (showdebuglist, from_tty, "");
1560 }
1561
1562 void
1563 init_cmd_lists (void)
1564 {
1565 max_user_call_depth = 1024;
1566
1567 cmdlist = NULL;
1568 infolist = NULL;
1569 enablelist = NULL;
1570 disablelist = NULL;
1571 togglelist = NULL;
1572 stoplist = NULL;
1573 deletelist = NULL;
1574 detachlist = NULL;
1575 setlist = NULL;
1576 unsetlist = NULL;
1577 showlist = NULL;
1578 sethistlist = NULL;
1579 showhistlist = NULL;
1580 unsethistlist = NULL;
1581 maintenancelist = NULL;
1582 maintenanceinfolist = NULL;
1583 maintenanceprintlist = NULL;
1584 setprintlist = NULL;
1585 showprintlist = NULL;
1586 setchecklist = NULL;
1587 showchecklist = NULL;
1588 }
1589
1590 static void
1591 show_info_verbose (struct ui_file *file, int from_tty,
1592 struct cmd_list_element *c,
1593 const char *value)
1594 {
1595 if (info_verbose)
1596 fprintf_filtered (file,
1597 _("Verbose printing of informational messages is %s.\n"),
1598 value);
1599 else
1600 fprintf_filtered (file, _("Verbosity is %s.\n"), value);
1601 }
1602
1603 static void
1604 show_history_expansion_p (struct ui_file *file, int from_tty,
1605 struct cmd_list_element *c, const char *value)
1606 {
1607 fprintf_filtered (file, _("History expansion on command input is %s.\n"),
1608 value);
1609 }
1610
1611 static void
1612 show_baud_rate (struct ui_file *file, int from_tty,
1613 struct cmd_list_element *c, const char *value)
1614 {
1615 fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
1616 value);
1617 }
1618
1619 static void
1620 show_remote_debug (struct ui_file *file, int from_tty,
1621 struct cmd_list_element *c, const char *value)
1622 {
1623 fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
1624 value);
1625 }
1626
1627 static void
1628 show_remote_timeout (struct ui_file *file, int from_tty,
1629 struct cmd_list_element *c, const char *value)
1630 {
1631 fprintf_filtered (file,
1632 _("Timeout limit to wait for target to respond is %s.\n"),
1633 value);
1634 }
1635
1636 static void
1637 show_max_user_call_depth (struct ui_file *file, int from_tty,
1638 struct cmd_list_element *c, const char *value)
1639 {
1640 fprintf_filtered (file,
1641 _("The max call depth for user-defined commands is %s.\n"),
1642 value);
1643 }
1644
1645 \f
1646 void
1647 init_cli_cmds (void)
1648 {
1649 struct cmd_list_element *c;
1650 char *source_help_text;
1651
1652 /* Define the classes of commands.
1653 They will appear in the help list in alphabetical order. */
1654
1655 add_cmd ("internals", class_maintenance, NULL, _("\
1656 Maintenance commands.\n\
1657 Some gdb commands are provided just for use by gdb maintainers.\n\
1658 These commands are subject to frequent change, and may not be as\n\
1659 well documented as user commands."),
1660 &cmdlist);
1661 add_cmd ("obscure", class_obscure, NULL, _("Obscure features."), &cmdlist);
1662 add_cmd ("aliases", class_alias, NULL,
1663 _("Aliases of other commands."), &cmdlist);
1664 add_cmd ("user-defined", class_user, NULL, _("\
1665 User-defined commands.\n\
1666 The commands in this class are those defined by the user.\n\
1667 Use the \"define\" command to define a command."), &cmdlist);
1668 add_cmd ("support", class_support, NULL, _("Support facilities."), &cmdlist);
1669 if (!dbx_commands)
1670 add_cmd ("status", class_info, NULL, _("Status inquiries."), &cmdlist);
1671 add_cmd ("files", class_files, NULL, _("Specifying and examining files."),
1672 &cmdlist);
1673 add_cmd ("breakpoints", class_breakpoint, NULL,
1674 _("Making program stop at certain points."), &cmdlist);
1675 add_cmd ("data", class_vars, NULL, _("Examining data."), &cmdlist);
1676 add_cmd ("stack", class_stack, NULL, _("\
1677 Examining the stack.\n\
1678 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
1679 counting from zero for the innermost (currently executing) frame.\n\n\
1680 At any time gdb identifies one frame as the \"selected\" frame.\n\
1681 Variable lookups are done with respect to the selected frame.\n\
1682 When the program being debugged stops, gdb selects the innermost frame.\n\
1683 The commands below can be used to select other frames by number or address."),
1684 &cmdlist);
1685 add_cmd ("running", class_run, NULL, _("Running the program."), &cmdlist);
1686
1687 /* Define general commands. */
1688
1689 add_com ("pwd", class_files, pwd_command, _("\
1690 Print working directory. This is used for your program as well."));
1691
1692 c = add_cmd ("cd", class_files, cd_command, _("\
1693 Set working directory to DIR for debugger and program being debugged.\n\
1694 The change does not take effect for the program being debugged\n\
1695 until the next time it is started."), &cmdlist);
1696 set_cmd_completer (c, filename_completer);
1697
1698 add_com ("echo", class_support, echo_command, _("\
1699 Print a constant string. Give string as argument.\n\
1700 C escape sequences may be used in the argument.\n\
1701 No newline is added at the end of the argument;\n\
1702 use \"\\n\" if you want a newline to be printed.\n\
1703 Since leading and trailing whitespace are ignored in command arguments,\n\
1704 if you want to print some you must use \"\\\" before leading whitespace\n\
1705 to be printed or after trailing whitespace."));
1706 add_com ("document", class_support, document_command, _("\
1707 Document a user-defined command.\n\
1708 Give command name as argument. Give documentation on following lines.\n\
1709 End with a line of just \"end\"."));
1710 add_com ("define", class_support, define_command, _("\
1711 Define a new command name. Command name is argument.\n\
1712 Definition appears on following lines, one command per line.\n\
1713 End with a line of just \"end\".\n\
1714 Use the \"document\" command to give documentation for the new command.\n\
1715 Commands defined in this way may have up to ten arguments."));
1716
1717 source_help_text = xstrprintf (_("\
1718 Read commands from a file named FILE.\n\
1719 \n\
1720 Usage: source [-s] [-v] FILE\n\
1721 -s: search for the script in the source search path,\n\
1722 even if FILE contains directories.\n\
1723 -v: each command in FILE is echoed as it is executed.\n\
1724 \n\
1725 Note that the file \"%s\" is read automatically in this way\n\
1726 when GDB is started."), gdbinit);
1727 c = add_cmd ("source", class_support, source_command,
1728 source_help_text, &cmdlist);
1729 set_cmd_completer (c, filename_completer);
1730
1731 add_setshow_enum_cmd ("script-extension", class_support,
1732 script_ext_enums, &script_ext_mode, _("\
1733 Set mode for script filename extension recognition."), _("\
1734 Show mode for script filename extension recognition."), _("\
1735 off == no filename extension recognition (all sourced files are GDB scripts)\n\
1736 soft == evaluate script according to filename extension, fallback to GDB script"
1737 "\n\
1738 strict == evaluate script according to filename extension, error if not supported"
1739 ),
1740 NULL,
1741 show_script_ext_mode,
1742 &setlist, &showlist);
1743
1744 add_com ("quit", class_support, quit_command, _("Exit gdb."));
1745 c = add_com ("help", class_support, help_command,
1746 _("Print list of commands."));
1747 set_cmd_completer (c, command_completer);
1748 add_com_alias ("q", "quit", class_support, 1);
1749 add_com_alias ("h", "help", class_support, 1);
1750
1751 add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
1752 Set verbosity."), _("\
1753 Show verbosity."), NULL,
1754 set_verbose,
1755 show_info_verbose,
1756 &setlist, &showlist);
1757
1758 add_prefix_cmd ("history", class_support, set_history,
1759 _("Generic command for setting command history parameters."),
1760 &sethistlist, "set history ", 0, &setlist);
1761 add_prefix_cmd ("history", class_support, show_history,
1762 _("Generic command for showing command history parameters."),
1763 &showhistlist, "show history ", 0, &showlist);
1764
1765 add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
1766 Set history expansion on command input."), _("\
1767 Show history expansion on command input."), _("\
1768 Without an argument, history expansion is enabled."),
1769 NULL,
1770 show_history_expansion_p,
1771 &sethistlist, &showhistlist);
1772
1773 add_prefix_cmd ("info", class_info, info_command, _("\
1774 Generic command for showing things about the program being debugged."),
1775 &infolist, "info ", 0, &cmdlist);
1776 add_com_alias ("i", "info", class_info, 1);
1777 add_com_alias ("inf", "info", class_info, 1);
1778
1779 add_com ("complete", class_obscure, complete_command,
1780 _("List the completions for the rest of the line as a command."));
1781
1782 add_prefix_cmd ("show", class_info, show_command, _("\
1783 Generic command for showing things about the debugger."),
1784 &showlist, "show ", 0, &cmdlist);
1785 /* Another way to get at the same thing. */
1786 add_info ("set", show_command, _("Show all GDB settings."));
1787
1788 add_cmd ("commands", no_set_class, show_commands, _("\
1789 Show the history of commands you typed.\n\
1790 You can supply a command number to start with, or a `+' to start after\n\
1791 the previous command number shown."),
1792 &showlist);
1793
1794 add_cmd ("version", no_set_class, show_version,
1795 _("Show what version of GDB this is."), &showlist);
1796
1797 add_com ("while", class_support, while_command, _("\
1798 Execute nested commands WHILE the conditional expression is non zero.\n\
1799 The conditional expression must follow the word `while' and must in turn be\n\
1800 followed by a new line. The nested commands must be entered one per line,\n\
1801 and should be terminated by the word `end'."));
1802
1803 add_com ("if", class_support, if_command, _("\
1804 Execute nested commands once IF the conditional expression is non zero.\n\
1805 The conditional expression must follow the word `if' and must in turn be\n\
1806 followed by a new line. The nested commands must be entered one per line,\n\
1807 and should be terminated by the word 'else' or `end'. If an else clause\n\
1808 is used, the same rules apply to its nested commands as to the first ones."));
1809
1810 /* If target is open when baud changes, it doesn't take effect until
1811 the next open (I think, not sure). */
1812 add_setshow_zinteger_cmd ("remotebaud", no_class, &baud_rate, _("\
1813 Set baud rate for remote serial I/O."), _("\
1814 Show baud rate for remote serial I/O."), _("\
1815 This value is used to set the speed of the serial port when debugging\n\
1816 using remote targets."),
1817 NULL,
1818 show_baud_rate,
1819 &setlist, &showlist);
1820
1821 add_setshow_zinteger_cmd ("remote", no_class, &remote_debug, _("\
1822 Set debugging of remote protocol."), _("\
1823 Show debugging of remote protocol."), _("\
1824 When enabled, each packet sent or received with the remote target\n\
1825 is displayed."),
1826 NULL,
1827 show_remote_debug,
1828 &setdebuglist, &showdebuglist);
1829
1830 add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class,
1831 &remote_timeout, _("\
1832 Set timeout limit to wait for target to respond."), _("\
1833 Show timeout limit to wait for target to respond."), _("\
1834 This value is used to set the time limit for gdb to wait for a response\n\
1835 from the target."),
1836 NULL,
1837 show_remote_timeout,
1838 &setlist, &showlist);
1839
1840 add_prefix_cmd ("debug", no_class, set_debug,
1841 _("Generic command for setting gdb debugging flags"),
1842 &setdebuglist, "set debug ", 0, &setlist);
1843
1844 add_prefix_cmd ("debug", no_class, show_debug,
1845 _("Generic command for showing gdb debugging flags"),
1846 &showdebuglist, "show debug ", 0, &showlist);
1847
1848 c = add_com ("shell", class_support, shell_escape, _("\
1849 Execute the rest of the line as a shell command.\n\
1850 With no arguments, run an inferior shell."));
1851 set_cmd_completer (c, filename_completer);
1852
1853 c = add_com ("edit", class_files, edit_command, _("\
1854 Edit specified file or function.\n\
1855 With no argument, edits file containing most recent line listed.\n\
1856 Editing targets can be specified in these ways:\n\
1857 FILE:LINENUM, to edit at that line in that file,\n\
1858 FUNCTION, to edit at the beginning of that function,\n\
1859 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1860 *ADDRESS, to edit at the line containing that address.\n\
1861 Uses EDITOR environment variable contents as editor (or ex as default)."));
1862
1863 c->completer = location_completer;
1864
1865 add_com ("list", class_files, list_command, _("\
1866 List specified function or line.\n\
1867 With no argument, lists ten more lines after or around previous listing.\n\
1868 \"list -\" lists the ten lines before a previous ten-line listing.\n\
1869 One argument specifies a line, and ten lines are listed around that line.\n\
1870 Two arguments with comma between specify starting and ending lines to list.\n\
1871 Lines can be specified in these ways:\n\
1872 LINENUM, to list around that line in current file,\n\
1873 FILE:LINENUM, to list around that line in that file,\n\
1874 FUNCTION, to list around beginning of that function,\n\
1875 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1876 *ADDRESS, to list around the line containing that address.\n\
1877 With two args if one is empty it stands for ten lines away from \
1878 the other arg."));
1879
1880 if (!xdb_commands)
1881 add_com_alias ("l", "list", class_files, 1);
1882 else
1883 add_com_alias ("v", "list", class_files, 1);
1884
1885 if (dbx_commands)
1886 add_com_alias ("file", "list", class_files, 1);
1887
1888 c = add_com ("disassemble", class_vars, disassemble_command, _("\
1889 Disassemble a specified section of memory.\n\
1890 Default is the function surrounding the pc of the selected frame.\n\
1891 With a /m modifier, source lines are included (if available).\n\
1892 With a /r modifier, raw instructions in hex are included.\n\
1893 With a single argument, the function surrounding that address is dumped.\n\
1894 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
1895 in the form of \"start,end\", or \"start,+length\"."));
1896 set_cmd_completer (c, location_completer);
1897 if (xdb_commands)
1898 add_com_alias ("va", "disassemble", class_xdb, 0);
1899
1900 add_com_alias ("!", "shell", class_support, 0);
1901
1902 c = add_com ("make", class_support, make_command, _("\
1903 Run the ``make'' program using the rest of the line as arguments."));
1904 set_cmd_completer (c, filename_completer);
1905 add_cmd ("user", no_class, show_user, _("\
1906 Show definitions of non-python user defined commands.\n\
1907 Argument is the name of the user defined command.\n\
1908 With no argument, show definitions of all user defined commands."), &showlist);
1909 add_com ("apropos", class_support, apropos_command,
1910 _("Search for commands matching a REGEXP"));
1911
1912 add_setshow_uinteger_cmd ("max-user-call-depth", no_class,
1913 &max_user_call_depth, _("\
1914 Set the max call depth for non-python user-defined commands."), _("\
1915 Show the max call depth for non-python user-defined commands."), NULL,
1916 NULL,
1917 show_max_user_call_depth,
1918 &setlist, &showlist);
1919
1920 add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
1921 Set tracing of GDB CLI commands."), _("\
1922 Show state of GDB CLI command tracing."), _("\
1923 When 'on', each command is displayed as it is executed."),
1924 NULL,
1925 NULL,
1926 &setlist, &showlist);
1927
1928 c = add_com ("alias", class_support, alias_command, _("\
1929 Define a new command that is an alias of an existing command.\n\
1930 Usage: alias [-a] [--] ALIAS = COMMAND\n\
1931 ALIAS is the name of the alias command to create.\n\
1932 COMMAND is the command being aliased to.\n\
1933 If \"-a\" is specified, the command is an abbreviation,\n\
1934 and will not appear in help command list output.\n\
1935 \n\
1936 Examples:\n\
1937 Make \"spe\" an alias of \"set print elements\":\n\
1938 alias spe = set print elements\n\
1939 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
1940 alias -a set print elms = set print elements"));
1941 }
This page took 0.071812 seconds and 4 git commands to generate.