GDB (xrefs)

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