]> Git Repo - binutils.git/blob - gdb/cli/cli-cmds.c
Unify gdb printf functions
[binutils.git] / gdb / cli / cli-cmds.c
1 /* GDB CLI commands.
2
3    Copyright (C) 2000-2022 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/tilde.h"
23 #include "completer.h"
24 #include "target.h"     /* For baud_rate, remote_debug and remote_timeout.  */
25 #include "gdbsupport/gdb_wait.h"        /* For shell escape implementation.  */
26 #include "gdbcmd.h"
27 #include "gdbsupport/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 "gdbsupport/filestuff.h"
40 #include "location.h"
41 #include "block.h"
42
43 #include "ui-out.h"
44 #include "interps.h"
45
46 #include "top.h"
47 #include "cli/cli-decode.h"
48 #include "cli/cli-script.h"
49 #include "cli/cli-setshow.h"
50 #include "cli/cli-cmds.h"
51 #include "cli/cli-style.h"
52 #include "cli/cli-utils.h"
53 #include "cli/cli-style.h"
54
55 #include "extension.h"
56 #include "gdbsupport/pathstuff.h"
57 #include "gdbsupport/gdb_tilde_expand.h"
58
59 #ifdef TUI
60 #include "tui/tui.h"    /* For tui_active et.al.  */
61 #endif
62
63 #include <fcntl.h>
64 #include <algorithm>
65 #include <string>
66
67 /* Prototypes for local utility functions */
68
69 static void print_sal_location (const symtab_and_line &sal);
70
71 static void ambiguous_line_spec (gdb::array_view<const symtab_and_line> sals,
72                                  const char *format, ...)
73   ATTRIBUTE_PRINTF (2, 3);
74
75 static void filter_sals (std::vector<symtab_and_line> &);
76
77 \f
78 /* See cli-cmds.h. */
79 unsigned int max_user_call_depth;
80
81 /* Define all cmd_list_elements.  */
82
83 /* Chain containing all defined commands.  */
84
85 struct cmd_list_element *cmdlist;
86
87 /* Chain containing all defined info subcommands.  */
88
89 struct cmd_list_element *infolist;
90
91 /* Chain containing all defined enable subcommands.  */
92
93 struct cmd_list_element *enablelist;
94
95 /* Chain containing all defined disable subcommands.  */
96
97 struct cmd_list_element *disablelist;
98
99 /* Chain containing all defined stop subcommands.  */
100
101 struct cmd_list_element *stoplist;
102
103 /* Chain containing all defined delete subcommands.  */
104
105 struct cmd_list_element *deletelist;
106
107 /* Chain containing all defined detach subcommands.  */
108
109 struct cmd_list_element *detachlist;
110
111 /* Chain containing all defined kill subcommands.  */
112
113 struct cmd_list_element *killlist;
114
115 /* Chain containing all defined set subcommands */
116
117 struct cmd_list_element *setlist;
118
119 /* Chain containing all defined unset subcommands */
120
121 struct cmd_list_element *unsetlist;
122
123 /* Chain containing all defined show subcommands.  */
124
125 struct cmd_list_element *showlist;
126
127 /* Chain containing all defined \"set history\".  */
128
129 struct cmd_list_element *sethistlist;
130
131 /* Chain containing all defined \"show history\".  */
132
133 struct cmd_list_element *showhistlist;
134
135 /* Chain containing all defined \"unset history\".  */
136
137 struct cmd_list_element *unsethistlist;
138
139 /* Chain containing all defined maintenance subcommands.  */
140
141 struct cmd_list_element *maintenancelist;
142
143 /* Chain containing all defined "maintenance info" subcommands.  */
144
145 struct cmd_list_element *maintenanceinfolist;
146
147 /* Chain containing all defined "maintenance print" subcommands.  */
148
149 struct cmd_list_element *maintenanceprintlist;
150
151 /* Chain containing all defined "maintenance check" subcommands.  */
152
153 struct cmd_list_element *maintenancechecklist;
154
155 /* Chain containing all defined "maintenance flush" subcommands.  */
156
157 struct cmd_list_element *maintenanceflushlist;
158
159 struct cmd_list_element *setprintlist;
160
161 struct cmd_list_element *showprintlist;
162
163 struct cmd_list_element *setdebuglist;
164
165 struct cmd_list_element *showdebuglist;
166
167 struct cmd_list_element *setchecklist;
168
169 struct cmd_list_element *showchecklist;
170
171 struct cmd_list_element *setsourcelist;
172
173 struct cmd_list_element *showsourcelist;
174
175 /* Command tracing state.  */
176
177 int source_verbose = 0;
178 bool trace_commands = false;
179 \f
180 /* 'script-extension' option support.  */
181
182 static const char script_ext_off[] = "off";
183 static const char script_ext_soft[] = "soft";
184 static const char script_ext_strict[] = "strict";
185
186 static const char *const script_ext_enums[] = {
187   script_ext_off,
188   script_ext_soft,
189   script_ext_strict,
190   NULL
191 };
192
193 static const char *script_ext_mode = script_ext_soft;
194 \f
195
196 /* User-controllable flag to suppress event notification on CLI.  */
197
198 static bool user_wants_cli_suppress_notification = false;
199
200 /* Utility used everywhere when at least one argument is needed and
201    none is supplied.  */
202
203 void
204 error_no_arg (const char *why)
205 {
206   error (_("Argument required (%s)."), why);
207 }
208
209 /* This implements the "info" prefix command.  Normally such commands
210    are automatically handled by add_basic_prefix_cmd, but in this case
211    a separate command is used so that it can be hooked into by
212    gdb-gdb.gdb.  */
213
214 static void
215 info_command (const char *arg, int from_tty)
216 {
217   help_list (infolist, "info ", all_commands, gdb_stdout);
218 }
219
220 /* See cli/cli-cmds.h.  */
221
222 void
223 with_command_1 (const char *set_cmd_prefix,
224                 cmd_list_element *setlist, const char *args, int from_tty)
225 {
226   if (args == nullptr)
227     error (_("Missing arguments."));
228
229   const char *delim = strstr (args, "--");
230   const char *nested_cmd = nullptr;
231
232   if (delim == args)
233     error (_("Missing setting before '--' delimiter"));
234
235   if (delim == nullptr || *skip_spaces (&delim[2]) == '\0')
236     nested_cmd = repeat_previous ();
237
238   cmd_list_element *set_cmd = lookup_cmd (&args, setlist, set_cmd_prefix,
239                                           nullptr,
240                                           /*allow_unknown=*/ 0,
241                                           /*ignore_help_classes=*/ 1);
242   gdb_assert (set_cmd != nullptr);
243
244   if (!set_cmd->var.has_value ())
245     error (_("Cannot use this setting with the \"with\" command"));
246
247   std::string temp_value
248     = (delim == nullptr ? args : std::string (args, delim - args));
249
250   if (nested_cmd == nullptr)
251     nested_cmd = skip_spaces (delim + 2);
252
253   gdb_assert (set_cmd->var.has_value ());
254   std::string org_value = get_setshow_command_value_string (*set_cmd->var);
255
256   /* Tweak the setting to the new temporary value.  */
257   do_set_command (temp_value.c_str (), from_tty, set_cmd);
258
259   try
260     {
261       scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
262
263       /* Execute the nested command.  */
264       execute_command (nested_cmd, from_tty);
265     }
266   catch (const gdb_exception &ex)
267     {
268       /* Restore the setting and rethrow.  If restoring the setting
269          throws, swallow the new exception and warn.  There's nothing
270          else we can reasonably do.  */
271       try
272         {
273           do_set_command (org_value.c_str (), from_tty, set_cmd);
274         }
275       catch (const gdb_exception &ex2)
276         {
277           warning (_("Couldn't restore setting: %s"), ex2.what ());
278         }
279
280       throw;
281     }
282
283   /* Restore the setting.  */
284   do_set_command (org_value.c_str (), from_tty, set_cmd);
285 }
286
287 /* See cli/cli-cmds.h.  */
288
289 void
290 with_command_completer_1 (const char *set_cmd_prefix,
291                           completion_tracker &tracker,
292                           const char *text)
293 {
294   tracker.set_use_custom_word_point (true);
295
296   const char *delim = strstr (text, "--");
297
298   /* If we're still not past the "--" delimiter, complete the "with"
299      command as if it was a "set" command.  */
300   if (delim == text
301       || delim == nullptr
302       || !isspace (delim[-1])
303       || !(isspace (delim[2]) || delim[2] == '\0'))
304     {
305       std::string new_text = std::string (set_cmd_prefix) + text;
306       tracker.advance_custom_word_point_by (-(int) strlen (set_cmd_prefix));
307       complete_nested_command_line (tracker, new_text.c_str ());
308       return;
309     }
310
311   /* We're past the "--" delimiter.  Complete on the sub command.  */
312   const char *nested_cmd = skip_spaces (delim + 2);
313   tracker.advance_custom_word_point_by (nested_cmd - text);
314   complete_nested_command_line (tracker, nested_cmd);
315 }
316
317 /* The "with" command.  */
318
319 static void
320 with_command (const char *args, int from_tty)
321 {
322   with_command_1 ("set ", setlist, args, from_tty);
323 }
324
325 /* "with" command completer.  */
326
327 static void
328 with_command_completer (struct cmd_list_element *ignore,
329                         completion_tracker &tracker,
330                         const char *text, const char * /*word*/)
331 {
332   with_command_completer_1 ("set ", tracker,  text);
333 }
334
335 /* Look up the contents of TEXT as a command usable with default args.
336    Throws an error if no such command is found.
337    Return the found command and advances TEXT past the found command.
338    If the found command is a postfix command, set *PREFIX_CMD to its
339    prefix command.  */
340
341 static struct cmd_list_element *
342 lookup_cmd_for_default_args (const char **text,
343                              struct cmd_list_element **prefix_cmd)
344 {
345   const char *orig_text = *text;
346   struct cmd_list_element *lcmd;
347
348   if (*text == nullptr || skip_spaces (*text) == nullptr)
349     error (_("ALIAS missing."));
350
351   /* We first use lookup_cmd to verify TEXT unambiguously identifies
352      a command.  */
353   lcmd = lookup_cmd (text, cmdlist, "", NULL,
354                      /*allow_unknown=*/ 0,
355                      /*ignore_help_classes=*/ 1);
356
357   /* Note that we accept default args for prefix commands,
358      as a prefix command can also be a valid usable
359      command accepting some arguments.
360      For example, "thread apply" applies a command to a
361      list of thread ids, and is also the prefix command for
362      thread apply all.  */
363
364   /* We have an unambiguous command for which default args
365      can be specified.  What remains after having found LCMD
366      is either spaces, or the default args character.  */
367
368   /* We then use lookup_cmd_composition to detect if the user
369      has specified an alias, and find the possible prefix_cmd
370      of cmd.  */
371   struct cmd_list_element *alias, *cmd;
372   lookup_cmd_composition
373     (std::string (orig_text, *text - orig_text).c_str (),
374      &alias, prefix_cmd, &cmd);
375   gdb_assert (cmd != nullptr);
376   gdb_assert (cmd == lcmd);
377   if (alias != nullptr)
378     cmd = alias;
379
380   return cmd;
381 }
382
383 /* Provide documentation on command or list given by COMMAND.  FROM_TTY
384    is ignored.  */
385
386 static void
387 help_command (const char *command, int from_tty)
388 {
389   help_cmd (command, gdb_stdout);
390 }
391 \f
392
393 /* Note: The "complete" command is used by Emacs to implement completion.
394    [Is that why this function writes output with *_unfiltered?]  */
395
396 static void
397 complete_command (const char *arg, int from_tty)
398 {
399   dont_repeat ();
400
401   if (max_completions == 0)
402     {
403       /* Only print this for non-mi frontends.  An MI frontend may not
404          be able to handle this.  */
405       if (!current_uiout->is_mi_like_p ())
406         {
407           printf_unfiltered (_("max-completions is zero,"
408                                " completion is disabled.\n"));
409         }
410       return;
411     }
412
413   if (arg == NULL)
414     arg = "";
415
416   int quote_char = '\0';
417   const char *word;
418
419   completion_result result = complete (arg, &word, &quote_char);
420
421   if (result.number_matches != 0)
422     {
423       std::string arg_prefix (arg, word - arg);
424
425       if (result.number_matches == 1)
426         printf_unfiltered ("%s%s\n", arg_prefix.c_str (), result.match_list[0]);
427       else
428         {
429           result.sort_match_list ();
430
431           for (size_t i = 0; i < result.number_matches; i++)
432             {
433               printf_unfiltered ("%s%s",
434                                  arg_prefix.c_str (),
435                                  result.match_list[i + 1]);
436               if (quote_char)
437                 printf_unfiltered ("%c", quote_char);
438               printf_unfiltered ("\n");
439             }
440         }
441
442       if (result.number_matches == max_completions)
443         {
444           /* ARG_PREFIX and WORD are included in the output so that emacs
445              will include the message in the output.  */
446           printf_unfiltered (_("%s%s %s\n"),
447                              arg_prefix.c_str (), word,
448                              get_max_completions_reached_message ());
449         }
450     }
451 }
452
453 int
454 is_complete_command (struct cmd_list_element *c)
455 {
456   return cmd_simple_func_eq (c, complete_command);
457 }
458
459 static void
460 show_version (const char *args, int from_tty)
461 {
462   print_gdb_version (gdb_stdout, true);
463   gdb_printf ("\n");
464 }
465
466 static void
467 show_configuration (const char *args, int from_tty)
468 {
469   print_gdb_configuration (gdb_stdout);
470 }
471
472 /* Handle the quit command.  */
473
474 void
475 quit_command (const char *args, int from_tty)
476 {
477   int exit_code = 0;
478
479   /* An optional expression may be used to cause gdb to terminate with
480      the value of that expression.  */
481   if (args)
482     {
483       struct value *val = parse_and_eval (args);
484
485       exit_code = (int) value_as_long (val);
486     }
487
488   if (!quit_confirm ())
489     error (_("Not confirmed."));
490
491   query_if_trace_running (from_tty);
492
493   quit_force (args ? &exit_code : NULL, from_tty);
494 }
495
496 static void
497 pwd_command (const char *args, int from_tty)
498 {
499   if (args)
500     error (_("The \"pwd\" command does not take an argument: %s"), args);
501
502   gdb::unique_xmalloc_ptr<char> cwd (getcwd (NULL, 0));
503
504   if (cwd == NULL)
505     error (_("Error finding name of working directory: %s"),
506            safe_strerror (errno));
507
508   if (strcmp (cwd.get (), current_directory) != 0)
509     gdb_printf (_("Working directory %ps\n (canonically %ps).\n"),
510                 styled_string (file_name_style.style (),
511                                current_directory),
512                 styled_string (file_name_style.style (), cwd.get ()));
513   else
514     gdb_printf (_("Working directory %ps.\n"),
515                 styled_string (file_name_style.style (),
516                                current_directory));
517 }
518
519 void
520 cd_command (const char *dir, int from_tty)
521 {
522   int len;
523   /* Found something other than leading repetitions of "/..".  */
524   int found_real_path;
525   char *p;
526
527   /* If the new directory is absolute, repeat is a no-op; if relative,
528      repeat might be useful but is more likely to be a mistake.  */
529   dont_repeat ();
530
531   gdb::unique_xmalloc_ptr<char> dir_holder
532     (tilde_expand (dir != NULL ? dir : "~"));
533   dir = dir_holder.get ();
534
535   if (chdir (dir) < 0)
536     perror_with_name (dir);
537
538 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
539   /* There's too much mess with DOSish names like "d:", "d:.",
540      "d:./foo" etc.  Instead of having lots of special #ifdef'ed code,
541      simply get the canonicalized name of the current directory.  */
542   gdb::unique_xmalloc_ptr<char> cwd (getcwd (NULL, 0));
543   dir = cwd.get ();
544 #endif
545
546   len = strlen (dir);
547   if (IS_DIR_SEPARATOR (dir[len - 1]))
548     {
549       /* Remove the trailing slash unless this is a root directory
550          (including a drive letter on non-Unix systems).  */
551       if (!(len == 1)           /* "/" */
552 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
553           && !(len == 3 && dir[1] == ':') /* "d:/" */
554 #endif
555           )
556         len--;
557     }
558
559   dir_holder.reset (savestring (dir, len));
560   if (IS_ABSOLUTE_PATH (dir_holder.get ()))
561     {
562       xfree (current_directory);
563       current_directory = dir_holder.release ();
564     }
565   else
566     {
567       if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1]))
568         current_directory = concat (current_directory, dir_holder.get (),
569                                     (char *) NULL);
570       else
571         current_directory = concat (current_directory, SLASH_STRING,
572                                     dir_holder.get (), (char *) NULL);
573     }
574
575   /* Now simplify any occurrences of `.' and `..' in the pathname.  */
576
577   found_real_path = 0;
578   for (p = current_directory; *p;)
579     {
580       if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
581           && (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
582         memmove (p, p + 2, strlen (p + 2) + 1);
583       else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
584                && (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
585         {
586           if (found_real_path)
587             {
588               /* Search backwards for the directory just before the "/.."
589                  and obliterate it and the "/..".  */
590               char *q = p;
591
592               while (q != current_directory && !IS_DIR_SEPARATOR (q[-1]))
593                 --q;
594
595               if (q == current_directory)
596                 /* current_directory is
597                    a relative pathname ("can't happen"--leave it alone).  */
598                 ++p;
599               else
600                 {
601                   memmove (q - 1, p + 3, strlen (p + 3) + 1);
602                   p = q - 1;
603                 }
604             }
605           else
606             /* We are dealing with leading repetitions of "/..", for
607                example "/../..", which is the Mach super-root.  */
608             p += 3;
609         }
610       else
611         {
612           found_real_path = 1;
613           ++p;
614         }
615     }
616
617   forget_cached_source_info ();
618
619   if (from_tty)
620     pwd_command ((char *) 0, 1);
621 }
622 \f
623 /* Show the current value of the 'script-extension' option.  */
624
625 static void
626 show_script_ext_mode (struct ui_file *file, int from_tty,
627                      struct cmd_list_element *c, const char *value)
628 {
629   gdb_printf (file,
630               _("Script filename extension recognition is \"%s\".\n"),
631               value);
632 }
633
634 /* Try to open SCRIPT_FILE.
635    If successful, the full path name is stored in *FULL_PATHP,
636    and the stream is returned.
637    If not successful, return NULL; errno is set for the last file
638    we tried to open.
639
640    If SEARCH_PATH is non-zero, and the file isn't found in cwd,
641    search for it in the source search path.  */
642
643 gdb::optional<open_script>
644 find_and_open_script (const char *script_file, int search_path)
645 {
646   int fd;
647   openp_flags search_flags = OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH;
648   gdb::optional<open_script> opened;
649
650   gdb::unique_xmalloc_ptr<char> file (tilde_expand (script_file));
651
652   if (search_path)
653     search_flags |= OPF_SEARCH_IN_PATH;
654
655   /* Search for and open 'file' on the search path used for source
656      files.  Put the full location in *FULL_PATHP.  */
657   gdb::unique_xmalloc_ptr<char> full_path;
658   fd = openp (source_path.c_str (), search_flags,
659               file.get (), O_RDONLY, &full_path);
660
661   if (fd == -1)
662     return opened;
663
664   FILE *result = fdopen (fd, FOPEN_RT);
665   if (result == NULL)
666     {
667       int save_errno = errno;
668
669       close (fd);
670       errno = save_errno;
671     }
672   else
673     opened.emplace (gdb_file_up (result), std::move (full_path));
674
675   return opened;
676 }
677
678 /* Load script FILE, which has already been opened as STREAM.
679    FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
680    This is provided as FILE may have been found via the source search path.
681    An important thing to note here is that FILE may be a symlink to a file
682    with a different or non-existing suffix, and thus one cannot infer the
683    extension language from FILE_TO_OPEN.  */
684
685 static void
686 source_script_from_stream (FILE *stream, const char *file,
687                            const char *file_to_open)
688 {
689   if (script_ext_mode != script_ext_off)
690     {
691       const struct extension_language_defn *extlang
692         = get_ext_lang_of_file (file);
693
694       if (extlang != NULL)
695         {
696           if (ext_lang_present_p (extlang))
697             {
698               script_sourcer_func *sourcer
699                 = ext_lang_script_sourcer (extlang);
700
701               gdb_assert (sourcer != NULL);
702               sourcer (extlang, stream, file_to_open);
703               return;
704             }
705           else if (script_ext_mode == script_ext_soft)
706             {
707               /* Assume the file is a gdb script.
708                  This is handled below.  */
709             }
710           else
711             throw_ext_lang_unsupported (extlang);
712         }
713     }
714
715   script_from_file (stream, file);
716 }
717
718 /* Worker to perform the "source" command.
719    Load script FILE.
720    If SEARCH_PATH is non-zero, and the file isn't found in cwd,
721    search for it in the source search path.  */
722
723 static void
724 source_script_with_search (const char *file, int from_tty, int search_path)
725 {
726
727   if (file == NULL || *file == 0)
728     error (_("source command requires file name of file to source."));
729
730   gdb::optional<open_script> opened = find_and_open_script (file, search_path);
731   if (!opened)
732     {
733       /* The script wasn't found, or was otherwise inaccessible.
734          If the source command was invoked interactively, throw an
735          error.  Otherwise (e.g. if it was invoked by a script),
736          just emit a warning, rather than cause an error.  */
737       if (from_tty)
738         perror_with_name (file);
739       else
740         {
741           perror_warning_with_name (file);
742           return;
743         }
744     }
745
746   /* The python support reopens the file, so we need to pass full_path here
747      in case the file was found on the search path.  It's useful to do this
748      anyway so that error messages show the actual file used.  But only do
749      this if we (may have) used search_path, as printing the full path in
750      errors for the non-search case can be more noise than signal.  */
751   const char *file_to_open;
752   gdb::unique_xmalloc_ptr<char> tilde_expanded_file;
753   if (search_path)
754     file_to_open = opened->full_path.get ();
755   else
756     {
757       tilde_expanded_file = gdb_tilde_expand_up (file);
758       file_to_open = tilde_expanded_file.get ();
759     }
760   source_script_from_stream (opened->stream.get (), file, file_to_open);
761 }
762
763 /* Wrapper around source_script_with_search to export it to main.c
764    for use in loading .gdbinit scripts.  */
765
766 void
767 source_script (const char *file, int from_tty)
768 {
769   source_script_with_search (file, from_tty, 0);
770 }
771
772 static void
773 source_command (const char *args, int from_tty)
774 {
775   const char *file = args;
776   int search_path = 0;
777
778   scoped_restore save_source_verbose = make_scoped_restore (&source_verbose);
779
780   /* -v causes the source command to run in verbose mode.
781      -s causes the file to be searched in the source search path,
782      even if the file name contains a '/'.
783      We still have to be able to handle filenames with spaces in a
784      backward compatible way, so buildargv is not appropriate.  */
785
786   if (args)
787     {
788       while (args[0] != '\0')
789         {
790           /* Make sure leading white space does not break the
791              comparisons.  */
792           args = skip_spaces (args);
793
794           if (args[0] != '-')
795             break;
796
797           if (args[1] == 'v' && isspace (args[2]))
798             {
799               source_verbose = 1;
800
801               /* Skip passed -v.  */
802               args = &args[3];
803             }
804           else if (args[1] == 's' && isspace (args[2]))
805             {
806               search_path = 1;
807
808               /* Skip passed -s.  */
809               args = &args[3];
810             }
811           else
812             break;
813         }
814
815       file = skip_spaces (args);
816     }
817
818   source_script_with_search (file, from_tty, search_path);
819 }
820
821
822 static void
823 echo_command (const char *text, int from_tty)
824 {
825   const char *p = text;
826   int c;
827
828   if (text)
829     while ((c = *p++) != '\0')
830       {
831         if (c == '\\')
832           {
833             /* \ at end of argument is used after spaces
834                so they won't be lost.  */
835             if (*p == 0)
836               return;
837
838             c = parse_escape (get_current_arch (), &p);
839             if (c >= 0)
840               gdb_printf ("%c", c);
841           }
842         else
843           gdb_printf ("%c", c);
844       }
845
846   gdb_stdout->reset_style ();
847
848   /* Force this output to appear now.  */
849   gdb_stdout->wrap_here (0);
850   gdb_flush (gdb_stdout);
851 }
852
853 /* Sets the last launched shell command convenience variables based on
854    EXIT_STATUS.  */
855
856 static void
857 exit_status_set_internal_vars (int exit_status)
858 {
859   struct internalvar *var_code = lookup_internalvar ("_shell_exitcode");
860   struct internalvar *var_signal = lookup_internalvar ("_shell_exitsignal");
861
862   clear_internalvar (var_code);
863   clear_internalvar (var_signal);
864   if (WIFEXITED (exit_status))
865     set_internalvar_integer (var_code, WEXITSTATUS (exit_status));
866 #ifdef __MINGW32__
867   else if (WIFSIGNALED (exit_status) && WTERMSIG (exit_status) == -1)
868     {
869       /* The -1 condition can happen on MinGW, if we don't recognize
870          the fatal exception code encoded in the exit status; see
871          gdbsupport/gdb_wait.c.  We don't want to lose information in
872          the exit status in that case.  Record it as a normal exit
873          with the full exit status, including the higher 0xC0000000
874          bits.  */
875       set_internalvar_integer (var_code, exit_status);
876     }
877 #endif
878   else if (WIFSIGNALED (exit_status))
879     set_internalvar_integer (var_signal, WTERMSIG (exit_status));
880   else
881     warning (_("unexpected shell command exit status %d"), exit_status);
882 }
883
884 static void
885 shell_escape (const char *arg, int from_tty)
886 {
887 #if defined(CANT_FORK) || \
888       (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
889   /* If ARG is NULL, they want an inferior shell, but `system' just
890      reports if the shell is available when passed a NULL arg.  */
891   int rc = system (arg ? arg : "");
892
893   if (!arg)
894     arg = "inferior shell";
895
896   if (rc == -1)
897     gdb_printf (gdb_stderr, "Cannot execute %s: %s\n", arg,
898                 safe_strerror (errno));
899   else if (rc)
900     gdb_printf (gdb_stderr, "%s exited with status %d\n", arg, rc);
901 #ifdef GLOBAL_CURDIR
902   /* Make sure to return to the directory GDB thinks it is, in case
903      the shell command we just ran changed it.  */
904   chdir (current_directory);
905 #endif
906   exit_status_set_internal_vars (rc);
907 #else /* Can fork.  */
908   int status, pid;
909
910   if ((pid = vfork ()) == 0)
911     {
912       const char *p, *user_shell = get_shell ();
913
914       close_most_fds ();
915
916       /* Get the name of the shell for arg0.  */
917       p = lbasename (user_shell);
918
919       if (!arg)
920         execl (user_shell, p, (char *) 0);
921       else
922         execl (user_shell, p, "-c", arg, (char *) 0);
923
924       gdb_printf (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
925                   safe_strerror (errno));
926       _exit (0177);
927     }
928
929   if (pid != -1)
930     waitpid (pid, &status, 0);
931   else
932     error (_("Fork failed"));
933   exit_status_set_internal_vars (status);
934 #endif /* Can fork.  */
935 }
936
937 /* Implementation of the "shell" command.  */
938
939 static void
940 shell_command (const char *arg, int from_tty)
941 {
942   shell_escape (arg, from_tty);
943 }
944
945 static void
946 edit_command (const char *arg, int from_tty)
947 {
948   struct symtab_and_line sal;
949   struct symbol *sym;
950   const char *editor;
951   const char *fn;
952
953   /* Pull in the current default source line if necessary.  */
954   if (arg == 0)
955     {
956       set_default_source_symtab_and_line ();
957       sal = get_current_source_symtab_and_line ();
958     }
959
960   /* Bare "edit" edits file with present line.  */
961
962   if (arg == 0)
963     {
964       if (sal.symtab == 0)
965         error (_("No default source file yet."));
966       sal.line += get_lines_to_list () / 2;
967     }
968   else
969     {
970       const char *arg1;
971
972       /* Now should only be one argument -- decode it in SAL.  */
973       arg1 = arg;
974       event_location_up location = string_to_event_location (&arg1,
975                                                              current_language);
976
977       if (*arg1)
978         error (_("Junk at end of line specification."));
979
980       std::vector<symtab_and_line> sals = decode_line_1 (location.get (),
981                                                          DECODE_LINE_LIST_MODE,
982                                                          NULL, NULL, 0);
983
984       filter_sals (sals);
985       if (sals.empty ())
986         {
987           /*  C++  */
988           return;
989         }
990       if (sals.size () > 1)
991         {
992           ambiguous_line_spec (sals,
993                                _("Specified line is ambiguous:\n"));
994           return;
995         }
996
997       sal = sals[0];
998
999       /* If line was specified by address, first print exactly which
1000          line, and which file.  In this case, sal.symtab == 0 means
1001          address is outside of all known source files, not that user
1002          failed to give a filename.  */
1003       if (*arg == '*')
1004         {
1005           struct gdbarch *gdbarch;
1006
1007           if (sal.symtab == 0)
1008             error (_("No source file for address %s."),
1009                    paddress (get_current_arch (), sal.pc));
1010
1011           gdbarch = sal.symtab->objfile ()->arch ();
1012           sym = find_pc_function (sal.pc);
1013           if (sym)
1014             gdb_printf ("%s is in %s (%s:%d).\n",
1015                         paddress (gdbarch, sal.pc),
1016                         sym->print_name (),
1017                         symtab_to_filename_for_display (sal.symtab),
1018                         sal.line);
1019           else
1020             gdb_printf ("%s is at %s:%d.\n",
1021                         paddress (gdbarch, sal.pc),
1022                         symtab_to_filename_for_display (sal.symtab),
1023                         sal.line);
1024         }
1025
1026       /* If what was given does not imply a symtab, it must be an
1027          undebuggable symbol which means no source code.  */
1028
1029       if (sal.symtab == 0)
1030         error (_("No line number known for %s."), arg);
1031     }
1032
1033   if ((editor = getenv ("EDITOR")) == NULL)
1034     editor = "/bin/ex";
1035
1036   fn = symtab_to_fullname (sal.symtab);
1037
1038   /* Quote the file name, in case it has whitespace or other special
1039      characters.  */
1040   gdb::unique_xmalloc_ptr<char> p
1041     = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn);
1042   shell_escape (p.get (), from_tty);
1043 }
1044
1045 /* The options for the "pipe" command.  */
1046
1047 struct pipe_cmd_opts
1048 {
1049   /* For "-d".  */
1050   std::string delimiter;
1051 };
1052
1053 static const gdb::option::option_def pipe_cmd_option_defs[] = {
1054
1055   gdb::option::string_option_def<pipe_cmd_opts> {
1056     "d",
1057     [] (pipe_cmd_opts *opts) { return &opts->delimiter; },
1058     nullptr,
1059     N_("Indicates to use the specified delimiter string to separate\n\
1060 COMMAND from SHELL_COMMAND, in alternative to |.  This is useful in\n\
1061 case COMMAND contains a | character."),
1062   },
1063
1064 };
1065
1066 /* Create an option_def_group for the "pipe" command's options, with
1067    OPTS as context.  */
1068
1069 static inline gdb::option::option_def_group
1070 make_pipe_cmd_options_def_group (pipe_cmd_opts *opts)
1071 {
1072   return {{pipe_cmd_option_defs}, opts};
1073 }
1074
1075 /* Implementation of the "pipe" command.  */
1076
1077 static void
1078 pipe_command (const char *arg, int from_tty)
1079 {
1080   pipe_cmd_opts opts;
1081
1082   auto grp = make_pipe_cmd_options_def_group (&opts);
1083   gdb::option::process_options
1084     (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
1085
1086   const char *delim = "|";
1087   if (!opts.delimiter.empty ())
1088     delim = opts.delimiter.c_str ();
1089
1090   const char *command = arg;
1091   if (command == nullptr)
1092     error (_("Missing COMMAND"));
1093
1094   arg = strstr (arg, delim);
1095
1096   if (arg == nullptr)
1097     error (_("Missing delimiter before SHELL_COMMAND"));
1098
1099   std::string gdb_cmd (command, arg - command);
1100
1101   arg += strlen (delim); /* Skip the delimiter.  */
1102
1103   if (gdb_cmd.empty ())
1104     gdb_cmd = repeat_previous ();
1105
1106   const char *shell_command = skip_spaces (arg);
1107   if (*shell_command == '\0')
1108     error (_("Missing SHELL_COMMAND"));
1109
1110   FILE *to_shell_command = popen (shell_command, "w");
1111
1112   if (to_shell_command == nullptr)
1113     error (_("Error launching \"%s\""), shell_command);
1114
1115   try
1116     {
1117       stdio_file pipe_file (to_shell_command);
1118
1119       execute_command_to_ui_file (&pipe_file, gdb_cmd.c_str (), from_tty);
1120     }
1121   catch (...)
1122     {
1123       pclose (to_shell_command);
1124       throw;
1125     }
1126
1127   int exit_status = pclose (to_shell_command);
1128
1129   if (exit_status < 0)
1130     error (_("shell command \"%s\" failed: %s"), shell_command,
1131            safe_strerror (errno));
1132   exit_status_set_internal_vars (exit_status);
1133 }
1134
1135 /* Completer for the pipe command.  */
1136
1137 static void
1138 pipe_command_completer (struct cmd_list_element *ignore,
1139                         completion_tracker &tracker,
1140                         const char *text, const char *word_ignored)
1141 {
1142   pipe_cmd_opts opts;
1143
1144   const char *org_text = text;
1145   auto grp = make_pipe_cmd_options_def_group (&opts);
1146   if (gdb::option::complete_options
1147       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp))
1148     return;
1149
1150   const char *delimiter = "|";
1151   if (!opts.delimiter.empty ())
1152     delimiter = opts.delimiter.c_str ();
1153
1154   /* Check if we're past option values already.  */
1155   if (text > org_text && !isspace (text[-1]))
1156     return;
1157
1158   const char *delim = strstr (text, delimiter);
1159
1160   /* If we're still not past the delimiter, complete the gdb
1161      command.  */
1162   if (delim == nullptr || delim == text)
1163     {
1164       complete_nested_command_line (tracker, text);
1165       return;
1166     }
1167
1168   /* We're past the delimiter.  What follows is a shell command, which
1169      we don't know how to complete.  */
1170 }
1171
1172 static void
1173 list_command (const char *arg, int from_tty)
1174 {
1175   struct symbol *sym;
1176   const char *arg1;
1177   int no_end = 1;
1178   int dummy_end = 0;
1179   int dummy_beg = 0;
1180   int linenum_beg = 0;
1181   const char *p;
1182
1183   /* Pull in the current default source line if necessary.  */
1184   if (arg == NULL || ((arg[0] == '+' || arg[0] == '-') && arg[1] == '\0'))
1185     {
1186       set_default_source_symtab_and_line ();
1187       symtab_and_line cursal = get_current_source_symtab_and_line ();
1188
1189       /* If this is the first "list" since we've set the current
1190          source line, center the listing around that line.  */
1191       if (get_first_line_listed () == 0)
1192         {
1193           int first;
1194
1195           first = std::max (cursal.line - get_lines_to_list () / 2, 1);
1196
1197           /* A small special case --- if listing backwards, and we
1198              should list only one line, list the preceding line,
1199              instead of the exact line we've just shown after e.g.,
1200              stopping for a breakpoint.  */
1201           if (arg != NULL && arg[0] == '-'
1202               && get_lines_to_list () == 1 && first > 1)
1203             first -= 1;
1204
1205           print_source_lines (cursal.symtab, source_lines_range (first), 0);
1206         }
1207
1208       /* "l" or "l +" lists next ten lines.  */
1209       else if (arg == NULL || arg[0] == '+')
1210         print_source_lines (cursal.symtab,
1211                             source_lines_range (cursal.line), 0);
1212
1213       /* "l -" lists previous ten lines, the ones before the ten just
1214          listed.  */
1215       else if (arg[0] == '-')
1216         {
1217           if (get_first_line_listed () == 1)
1218             error (_("Already at the start of %s."),
1219                    symtab_to_filename_for_display (cursal.symtab));
1220           source_lines_range range (get_first_line_listed (),
1221                                     source_lines_range::BACKWARD);
1222           print_source_lines (cursal.symtab, range, 0);
1223         }
1224
1225       return;
1226     }
1227
1228   /* Now if there is only one argument, decode it in SAL
1229      and set NO_END.
1230      If there are two arguments, decode them in SAL and SAL_END
1231      and clear NO_END; however, if one of the arguments is blank,
1232      set DUMMY_BEG or DUMMY_END to record that fact.  */
1233
1234   if (!have_full_symbols () && !have_partial_symbols ())
1235     error (_("No symbol table is loaded.  Use the \"file\" command."));
1236
1237   std::vector<symtab_and_line> sals;
1238   symtab_and_line sal, sal_end;
1239
1240   arg1 = arg;
1241   if (*arg1 == ',')
1242     dummy_beg = 1;
1243   else
1244     {
1245       event_location_up location = string_to_event_location (&arg1,
1246                                                              current_language);
1247
1248       /* We know that the ARG string is not empty, yet the attempt to parse
1249          a location from the string consumed no characters.  This most
1250          likely means that the first thing in ARG looks like a location
1251          condition, and so the string_to_event_location call stopped
1252          parsing.  */
1253       if (arg1 == arg)
1254         error (_("Junk at end of line specification."));
1255
1256       sals = decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
1257                             NULL, NULL, 0);
1258       filter_sals (sals);
1259       if (sals.empty ())
1260         {
1261           /*  C++  */
1262           return;
1263         }
1264
1265       sal = sals[0];
1266     }
1267
1268   /* Record whether the BEG arg is all digits.  */
1269
1270   for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
1271   linenum_beg = (p == arg1);
1272
1273   /* Save the range of the first argument, in case we need to let the
1274      user know it was ambiguous.  */
1275   const char *beg = arg;
1276   size_t beg_len = arg1 - beg;
1277
1278   while (*arg1 == ' ' || *arg1 == '\t')
1279     arg1++;
1280   if (*arg1 == ',')
1281     {
1282       no_end = 0;
1283       if (sals.size () > 1)
1284         {
1285           ambiguous_line_spec (sals,
1286                                _("Specified first line '%.*s' is ambiguous:\n"),
1287                                (int) beg_len, beg);
1288           return;
1289         }
1290       arg1++;
1291       while (*arg1 == ' ' || *arg1 == '\t')
1292         arg1++;
1293       if (*arg1 == 0)
1294         dummy_end = 1;
1295       else
1296         {
1297           /* Save the last argument, in case we need to let the user
1298              know it was ambiguous.  */
1299           const char *end_arg = arg1;
1300
1301           event_location_up location
1302             = string_to_event_location (&arg1, current_language);
1303
1304           if (*arg1)
1305             error (_("Junk at end of line specification."));
1306
1307           std::vector<symtab_and_line> sals_end
1308             = (dummy_beg
1309                ? decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
1310                                 NULL, NULL, 0)
1311                : decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
1312                                 NULL, sal.symtab, sal.line));
1313
1314           filter_sals (sals_end);
1315           if (sals_end.empty ())
1316             return;
1317           if (sals_end.size () > 1)
1318             {
1319               ambiguous_line_spec (sals_end,
1320                                    _("Specified last line '%s' is ambiguous:\n"),
1321                                    end_arg);
1322               return;
1323             }
1324           sal_end = sals_end[0];
1325         }
1326     }
1327
1328   if (*arg1)
1329     error (_("Junk at end of line specification."));
1330
1331   if (!no_end && !dummy_beg && !dummy_end
1332       && sal.symtab != sal_end.symtab)
1333     error (_("Specified first and last lines are in different files."));
1334   if (dummy_beg && dummy_end)
1335     error (_("Two empty args do not say what lines to list."));
1336
1337   /* If line was specified by address,
1338      first print exactly which line, and which file.
1339
1340      In this case, sal.symtab == 0 means address is outside of all
1341      known source files, not that user failed to give a filename.  */
1342   if (*arg == '*')
1343     {
1344       struct gdbarch *gdbarch;
1345
1346       if (sal.symtab == 0)
1347         error (_("No source file for address %s."),
1348                paddress (get_current_arch (), sal.pc));
1349
1350       gdbarch = sal.symtab->objfile ()->arch ();
1351       sym = find_pc_function (sal.pc);
1352       if (sym)
1353         gdb_printf ("%s is in %s (%s:%d).\n",
1354                     paddress (gdbarch, sal.pc),
1355                     sym->print_name (),
1356                     symtab_to_filename_for_display (sal.symtab), sal.line);
1357       else
1358         gdb_printf ("%s is at %s:%d.\n",
1359                     paddress (gdbarch, sal.pc),
1360                     symtab_to_filename_for_display (sal.symtab), sal.line);
1361     }
1362
1363   /* If line was not specified by just a line number, and it does not
1364      imply a symtab, it must be an undebuggable symbol which means no
1365      source code.  */
1366
1367   if (!linenum_beg && sal.symtab == 0)
1368     error (_("No line number known for %s."), arg);
1369
1370   /* If this command is repeated with RET,
1371      turn it into the no-arg variant.  */
1372
1373   if (from_tty)
1374     set_repeat_arguments ("");
1375
1376   if (dummy_beg && sal_end.symtab == 0)
1377     error (_("No default source file yet.  Do \"help list\"."));
1378   if (dummy_beg)
1379     {
1380       source_lines_range range (sal_end.line + 1,
1381                                 source_lines_range::BACKWARD);
1382       print_source_lines (sal_end.symtab, range, 0);
1383     }
1384   else if (sal.symtab == 0)
1385     error (_("No default source file yet.  Do \"help list\"."));
1386   else if (no_end)
1387     {
1388       for (int i = 0; i < sals.size (); i++)
1389         {
1390           sal = sals[i];
1391           int first_line = sal.line - get_lines_to_list () / 2;
1392           if (first_line < 1)
1393             first_line = 1;
1394           if (sals.size () > 1)
1395             print_sal_location (sal);
1396           print_source_lines (sal.symtab, source_lines_range (first_line), 0);
1397         }
1398     }
1399   else if (dummy_end)
1400     print_source_lines (sal.symtab, source_lines_range (sal.line), 0);
1401   else
1402     print_source_lines (sal.symtab,
1403                         source_lines_range (sal.line, (sal_end.line + 1)),
1404                         0);
1405 }
1406
1407 /* Subroutine of disassemble_command to simplify it.
1408    Perform the disassembly.
1409    NAME is the name of the function if known, or NULL.
1410    [LOW,HIGH) are the range of addresses to disassemble.
1411    BLOCK is the block to disassemble; it needs to be provided
1412    when non-contiguous blocks are disassembled; otherwise
1413    it can be NULL.
1414    MIXED is non-zero to print source with the assembler.  */
1415
1416 static void
1417 print_disassembly (struct gdbarch *gdbarch, const char *name,
1418                    CORE_ADDR low, CORE_ADDR high,
1419                    const struct block *block,
1420                    gdb_disassembly_flags flags)
1421 {
1422 #if defined(TUI)
1423   if (tui_is_window_visible (DISASSEM_WIN))
1424     tui_show_assembly (gdbarch, low);
1425   else
1426 #endif
1427     {
1428       gdb_printf (_("Dump of assembler code "));
1429       if (name != NULL)
1430         gdb_printf (_("for function %ps:\n"),
1431                     styled_string (function_name_style.style (), name));
1432       if (block == nullptr || BLOCK_CONTIGUOUS_P (block))
1433         {
1434           if (name == NULL)
1435             gdb_printf (_("from %ps to %ps:\n"),
1436                         styled_string (address_style.style (),
1437                                        paddress (gdbarch, low)),
1438                         styled_string (address_style.style (),
1439                                        paddress (gdbarch, high)));
1440
1441           /* Dump the specified range.  */
1442           gdb_disassembly (gdbarch, current_uiout, flags, -1, low, high);
1443         }
1444       else
1445         {
1446           for (int i = 0; i < BLOCK_NRANGES (block); i++)
1447             {
1448               CORE_ADDR range_low = BLOCK_RANGE_START (block, i);
1449               CORE_ADDR range_high = BLOCK_RANGE_END (block, i);
1450               gdb_printf (_("Address range %ps to %ps:\n"),
1451                           styled_string (address_style.style (),
1452                                          paddress (gdbarch, range_low)),
1453                           styled_string (address_style.style (),
1454                                          paddress (gdbarch, range_high)));
1455               gdb_disassembly (gdbarch, current_uiout, flags, -1,
1456                                range_low, range_high);
1457             }
1458         }
1459       gdb_printf (_("End of assembler dump.\n"));
1460     }
1461 }
1462
1463 /* Subroutine of disassemble_command to simplify it.
1464    Print a disassembly of the current function according to FLAGS.  */
1465
1466 static void
1467 disassemble_current_function (gdb_disassembly_flags flags)
1468 {
1469   struct frame_info *frame;
1470   struct gdbarch *gdbarch;
1471   CORE_ADDR low, high, pc;
1472   const char *name;
1473   const struct block *block;
1474
1475   frame = get_selected_frame (_("No frame selected."));
1476   gdbarch = get_frame_arch (frame);
1477   pc = get_frame_address_in_block (frame);
1478   if (find_pc_partial_function (pc, &name, &low, &high, &block) == 0)
1479     error (_("No function contains program counter for selected frame."));
1480 #if defined(TUI)
1481   /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1482      `tui_version'.  */
1483   if (tui_active)
1484     /* FIXME: cagney/2004-02-07: This should be an observer.  */
1485     low = tui_get_low_disassembly_address (gdbarch, low, pc);
1486 #endif
1487   low += gdbarch_deprecated_function_start_offset (gdbarch);
1488
1489   print_disassembly (gdbarch, name, low, high, block, flags);
1490 }
1491
1492 /* Dump a specified section of assembly code.
1493
1494    Usage:
1495      disassemble [/mrs]
1496        - dump the assembly code for the function of the current pc
1497      disassemble [/mrs] addr
1498        - dump the assembly code for the function at ADDR
1499      disassemble [/mrs] low,high
1500      disassemble [/mrs] low,+length
1501        - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
1502
1503    A /m modifier will include source code with the assembly in a
1504    "source centric" view.  This view lists only the file of the first insn,
1505    even if other source files are involved (e.g., inlined functions), and
1506    the output is in source order, even with optimized code.  This view is
1507    considered deprecated as it hasn't been useful in practice.
1508
1509    A /r modifier will include raw instructions in hex with the assembly.
1510
1511    A /s modifier will include source code with the assembly, like /m, with
1512    two important differences:
1513    1) The output is still in pc address order.
1514    2) File names and contents for all relevant source files are displayed.  */
1515
1516 static void
1517 disassemble_command (const char *arg, int from_tty)
1518 {
1519   struct gdbarch *gdbarch = get_current_arch ();
1520   CORE_ADDR low, high;
1521   const general_symbol_info *symbol = nullptr;
1522   const char *name;
1523   CORE_ADDR pc;
1524   gdb_disassembly_flags flags;
1525   const char *p;
1526   const struct block *block = nullptr;
1527
1528   p = arg;
1529   name = NULL;
1530   flags = 0;
1531
1532   if (p && *p == '/')
1533     {
1534       ++p;
1535
1536       if (*p == '\0')
1537         error (_("Missing modifier."));
1538
1539       while (*p && ! isspace (*p))
1540         {
1541           switch (*p++)
1542             {
1543             case 'm':
1544               flags |= DISASSEMBLY_SOURCE_DEPRECATED;
1545               break;
1546             case 'r':
1547               flags |= DISASSEMBLY_RAW_INSN;
1548               break;
1549             case 's':
1550               flags |= DISASSEMBLY_SOURCE;
1551               break;
1552             default:
1553               error (_("Invalid disassembly modifier."));
1554             }
1555         }
1556
1557       p = skip_spaces (p);
1558     }
1559
1560   if ((flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
1561       == (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
1562     error (_("Cannot specify both /m and /s."));
1563
1564   if (! p || ! *p)
1565     {
1566       flags |= DISASSEMBLY_OMIT_FNAME;
1567       disassemble_current_function (flags);
1568       return;
1569     }
1570
1571   pc = value_as_address (parse_to_comma_and_eval (&p));
1572   if (p[0] == ',')
1573     ++p;
1574   if (p[0] == '\0')
1575     {
1576       /* One argument.  */
1577       if (!find_pc_partial_function_sym (pc, &symbol, &low, &high, &block))
1578         error (_("No function contains specified address."));
1579
1580       if (asm_demangle)
1581         name = symbol->print_name ();
1582       else
1583         name = symbol->linkage_name ();
1584
1585 #if defined(TUI)
1586       /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1587          `tui_version'.  */
1588       if (tui_active)
1589         /* FIXME: cagney/2004-02-07: This should be an observer.  */
1590         low = tui_get_low_disassembly_address (gdbarch, low, pc);
1591 #endif
1592       low += gdbarch_deprecated_function_start_offset (gdbarch);
1593       flags |= DISASSEMBLY_OMIT_FNAME;
1594     }
1595   else
1596     {
1597       /* Two arguments.  */
1598       int incl_flag = 0;
1599       low = pc;
1600       p = skip_spaces (p);
1601       if (p[0] == '+')
1602         {
1603           ++p;
1604           incl_flag = 1;
1605         }
1606       high = parse_and_eval_address (p);
1607       if (incl_flag)
1608         high += low;
1609     }
1610
1611   print_disassembly (gdbarch, name, low, high, block, flags);
1612 }
1613
1614 static void
1615 make_command (const char *arg, int from_tty)
1616 {
1617   if (arg == 0)
1618     shell_escape ("make", from_tty);
1619   else
1620     {
1621       std::string cmd = std::string ("make ") + arg;
1622
1623       shell_escape (cmd.c_str (), from_tty);
1624     }
1625 }
1626
1627 static void
1628 show_user (const char *args, int from_tty)
1629 {
1630   struct cmd_list_element *c;
1631
1632   if (args)
1633     {
1634       const char *comname = args;
1635
1636       c = lookup_cmd (&comname, cmdlist, "", NULL, 0, 1);
1637       if (!cli_user_command_p (c))
1638         error (_("Not a user command."));
1639       show_user_1 (c, "", args, gdb_stdout);
1640     }
1641   else
1642     {
1643       for (c = cmdlist; c; c = c->next)
1644         {
1645           if (cli_user_command_p (c) || c->is_prefix ())
1646             show_user_1 (c, "", c->name, gdb_stdout);
1647         }
1648     }
1649 }
1650
1651 /* Return true if COMMAND or any of its sub-commands is a user defined command.
1652    This is a helper function for show_user_completer.  */
1653
1654 static bool
1655 has_user_subcmd (struct cmd_list_element *command)
1656 {
1657   if (cli_user_command_p (command))
1658     return true;
1659
1660   /* Alias command can yield false positive.  Ignore them as the targeted
1661      command should be reachable anyway.  */
1662   if (command->is_alias ())
1663     return false;
1664
1665   if (command->is_prefix ())
1666     for (struct cmd_list_element *subcommand = *command->subcommands;
1667          subcommand != nullptr;
1668          subcommand = subcommand->next)
1669       if (has_user_subcmd (subcommand))
1670         return true;
1671
1672   return false;
1673 }
1674
1675 /* Implement completer for the 'show user' command.  */
1676
1677 static void
1678 show_user_completer (cmd_list_element *,
1679                      completion_tracker &tracker, const char *text,
1680                      const char *word)
1681 {
1682   struct cmd_list_element *cmd_group = cmdlist;
1683
1684   /* TEXT can contain a chain of commands and subcommands.  Follow the
1685      commands chain until we reach the point where the user wants a
1686      completion.  */
1687   while (word > text)
1688     {
1689       const char *curr_cmd = text;
1690       const char *after = skip_to_space (text);
1691       const size_t curr_cmd_len = after - text;
1692       text = skip_spaces (after);
1693
1694       for (struct cmd_list_element *c = cmd_group; c != nullptr; c = c->next)
1695         {
1696           if (strlen (c->name) == curr_cmd_len
1697               && strncmp (c->name, curr_cmd, curr_cmd_len) == 0)
1698             {
1699               if (c->subcommands == nullptr)
1700                 /* We arrived after a command with no child, so nothing more
1701                    to complete.  */
1702                 return;
1703
1704               cmd_group = *c->subcommands;
1705               break;
1706             }
1707         }
1708     }
1709
1710   const int wordlen = strlen (word);
1711   for (struct cmd_list_element *c = cmd_group; c != nullptr; c = c->next)
1712     if (has_user_subcmd (c))
1713       {
1714         if (strncmp (c->name, word, wordlen) == 0)
1715           tracker.add_completion
1716             (gdb::unique_xmalloc_ptr<char> (xstrdup (c->name)));
1717       }
1718 }
1719
1720 /* Search through names of commands and documentations for a certain
1721    regular expression.  */
1722
1723 static void
1724 apropos_command (const char *arg, int from_tty)
1725 {
1726   bool verbose = arg && check_for_argument (&arg, "-v", 2);
1727
1728   if (arg == NULL || *arg == '\0')
1729     error (_("REGEXP string is empty"));
1730
1731   compiled_regex pattern (arg, REG_ICASE,
1732                           _("Error in regular expression"));
1733
1734   apropos_cmd (gdb_stdout, cmdlist, verbose, pattern, "");
1735 }
1736
1737 /* The options for the "alias" command.  */
1738
1739 struct alias_opts
1740 {
1741   /* For "-a".  */
1742   bool abbrev_flag = false;
1743 };
1744
1745 static const gdb::option::option_def alias_option_defs[] = {
1746
1747   gdb::option::flag_option_def<alias_opts> {
1748     "a",
1749     [] (alias_opts *opts) { return &opts->abbrev_flag; },
1750     N_("Specify that ALIAS is an abbreviation of COMMAND.\n\
1751 Abbreviations are not used in command completion."),
1752   },
1753
1754 };
1755
1756 /* Create an option_def_group for the "alias" options, with
1757    A_OPTS as context.  */
1758
1759 static gdb::option::option_def_group
1760 make_alias_options_def_group (alias_opts *a_opts)
1761 {
1762   return {{alias_option_defs}, a_opts};
1763 }
1764
1765 /* Completer for the "alias_command".  */
1766
1767 static void
1768 alias_command_completer (struct cmd_list_element *ignore,
1769                          completion_tracker &tracker,
1770                          const char *text, const char *word)
1771 {
1772   const auto grp = make_alias_options_def_group (nullptr);
1773
1774   tracker.set_use_custom_word_point (true);
1775
1776   if (gdb::option::complete_options
1777       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp))
1778     return;
1779
1780   const char *delim = strchr (text, '=');
1781
1782   /* If we're past the "=" delimiter, complete the
1783      "alias ALIAS = COMMAND [DEFAULT-ARGS...]" as if the user is
1784      typing COMMAND DEFAULT-ARGS...  */
1785   if (delim != text
1786       && delim != nullptr
1787       && isspace (delim[-1])
1788       && (isspace (delim[1]) || delim[1] == '\0'))
1789     {
1790       std::string new_text = std::string (delim + 1);
1791
1792       tracker.advance_custom_word_point_by (delim + 1 - text);
1793       complete_nested_command_line (tracker, new_text.c_str ());
1794       return;
1795     }
1796
1797   /* We're not yet past the "=" delimiter.  Complete a command, as
1798      the user might type an alias following a prefix command.  */
1799   complete_nested_command_line (tracker, text);
1800 }
1801
1802 /* Subroutine of alias_command to simplify it.
1803    Return the first N elements of ARGV flattened back to a string
1804    with a space separating each element.
1805    ARGV may not be NULL.
1806    This does not take care of quoting elements in case they contain spaces
1807    on purpose.  */
1808
1809 static std::string
1810 argv_to_string (char **argv, int n)
1811 {
1812   int i;
1813   std::string result;
1814
1815   gdb_assert (argv != NULL);
1816   gdb_assert (n >= 0 && n <= countargv (argv));
1817
1818   for (i = 0; i < n; ++i)
1819     {
1820       if (i > 0)
1821         result += " ";
1822       result += argv[i];
1823     }
1824
1825   return result;
1826 }
1827
1828 /* Subroutine of alias_command to simplify it.
1829    Verifies that COMMAND can have an alias:
1830       COMMAND must exist.
1831       COMMAND must not have default args.
1832    This last condition is to avoid the following:
1833      alias aaa = backtrace -full
1834      alias bbb = aaa -past-main
1835    as (at least currently), alias default args are not cumulative
1836    and the user would expect bbb to execute 'backtrace -full -past-main'
1837    while it will execute 'backtrace -past-main'.  */
1838
1839 static cmd_list_element *
1840 validate_aliased_command (const char *command)
1841 {
1842   std::string default_args;
1843   cmd_list_element *c
1844     = lookup_cmd_1 (& command, cmdlist, NULL, &default_args, 1);
1845
1846   if (c == NULL || c == (struct cmd_list_element *) -1)
1847     error (_("Invalid command to alias to: %s"), command);
1848
1849   if (!default_args.empty ())
1850     error (_("Cannot define an alias of an alias that has default args"));
1851
1852   return c;
1853 }
1854
1855 /* Called when "alias" was incorrectly used.  */
1856
1857 static void
1858 alias_usage_error (void)
1859 {
1860   error (_("Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]"));
1861 }
1862
1863 /* Make an alias of an existing command.  */
1864
1865 static void
1866 alias_command (const char *args, int from_tty)
1867 {
1868   alias_opts a_opts;
1869
1870   auto grp = make_alias_options_def_group (&a_opts);
1871   gdb::option::process_options
1872     (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp);
1873
1874   int i, alias_argc, command_argc;
1875   const char *equals;
1876   const char *alias, *command;
1877
1878   if (args == NULL || strchr (args, '=') == NULL)
1879     alias_usage_error ();
1880
1881   equals = strchr (args, '=');
1882   std::string args2 (args, equals - args);
1883
1884   gdb_argv built_alias_argv (args2.c_str ());
1885
1886   const char *default_args = equals + 1;
1887   struct cmd_list_element *c_command_prefix;
1888
1889   lookup_cmd_for_default_args (&default_args, &c_command_prefix);
1890   std::string command_argv_str (equals + 1,
1891                                 default_args == nullptr
1892                                 ? strlen (equals + 1)
1893                                 : default_args - equals - 1);
1894   gdb_argv command_argv (command_argv_str.c_str ());
1895
1896   char **alias_argv = built_alias_argv.get ();
1897
1898   if (alias_argv[0] == NULL || command_argv[0] == NULL
1899       || *alias_argv[0] == '\0' || *command_argv[0] == '\0')
1900     alias_usage_error ();
1901
1902   for (i = 0; alias_argv[i] != NULL; ++i)
1903     {
1904       if (! valid_user_defined_cmd_name_p (alias_argv[i]))
1905         {
1906           if (i == 0)
1907             error (_("Invalid command name: %s"), alias_argv[i]);
1908           else
1909             error (_("Invalid command element name: %s"), alias_argv[i]);
1910         }
1911     }
1912
1913   alias_argc = countargv (alias_argv);
1914   command_argc = command_argv.count ();
1915
1916   /* COMMAND must exist, and cannot have default args.
1917      Reconstruct the command to remove any extraneous spaces,
1918      for better error messages.  */
1919   std::string command_string (argv_to_string (command_argv.get (),
1920                                               command_argc));
1921   command = command_string.c_str ();
1922   cmd_list_element *target_cmd = validate_aliased_command (command);
1923
1924   /* ALIAS must not exist.  */
1925   std::string alias_string (argv_to_string (alias_argv, alias_argc));
1926   alias = alias_string.c_str ();
1927   {
1928     cmd_list_element *alias_cmd, *prefix_cmd, *cmd;
1929
1930     if (lookup_cmd_composition (alias, &alias_cmd, &prefix_cmd, &cmd))
1931       {
1932         const char *alias_name = alias_argv[alias_argc-1];
1933
1934         /* If we found an existing ALIAS_CMD, check that the prefix differ or
1935            the name differ.  */
1936
1937         if (alias_cmd != nullptr
1938             && alias_cmd->prefix == prefix_cmd
1939             && strcmp (alias_name, alias_cmd->name) == 0)
1940           error (_("Alias already exists: %s"), alias);
1941
1942         /* Check ALIAS differs from the found CMD.  */
1943
1944         if (cmd->prefix == prefix_cmd
1945             && strcmp (alias_name, cmd->name) == 0)
1946           error (_("Alias %s is the name of an existing command"), alias);
1947       }
1948   }
1949
1950
1951   struct cmd_list_element *alias_cmd;
1952
1953   /* If ALIAS is one word, it is an alias for the entire COMMAND.
1954      Example: alias spe = set print elements
1955
1956      Otherwise ALIAS and COMMAND must have the same number of words,
1957      and every word except the last must identify the same prefix command;
1958      and the last word of ALIAS is made an alias of the last word of COMMAND.
1959      Example: alias set print elms = set pr elem
1960      Note that unambiguous abbreviations are allowed.  */
1961
1962   if (alias_argc == 1)
1963     {
1964       /* add_cmd requires *we* allocate space for name, hence the xstrdup.  */
1965       alias_cmd = add_com_alias (xstrdup (alias_argv[0]), target_cmd,
1966                                  class_alias, a_opts.abbrev_flag);
1967     }
1968   else
1969     {
1970       const char *alias_prefix, *command_prefix;
1971       struct cmd_list_element *c_alias, *c_command;
1972
1973       if (alias_argc != command_argc)
1974         error (_("Mismatched command length between ALIAS and COMMAND."));
1975
1976       /* Create copies of ALIAS and COMMAND without the last word,
1977          and use that to verify the leading elements give the same
1978          prefix command.  */
1979       std::string alias_prefix_string (argv_to_string (alias_argv,
1980                                                        alias_argc - 1));
1981       std::string command_prefix_string (argv_to_string (command_argv.get (),
1982                                                          command_argc - 1));
1983       alias_prefix = alias_prefix_string.c_str ();
1984       command_prefix = command_prefix_string.c_str ();
1985
1986       c_command = lookup_cmd_1 (& command_prefix, cmdlist, NULL, NULL, 1);
1987       /* We've already tried to look up COMMAND.  */
1988       gdb_assert (c_command != NULL
1989                   && c_command != (struct cmd_list_element *) -1);
1990       gdb_assert (c_command->is_prefix ());
1991       c_alias = lookup_cmd_1 (& alias_prefix, cmdlist, NULL, NULL, 1);
1992       if (c_alias != c_command)
1993         error (_("ALIAS and COMMAND prefixes do not match."));
1994
1995       /* add_cmd requires *we* allocate space for name, hence the xstrdup.  */
1996       alias_cmd = add_alias_cmd (xstrdup (alias_argv[alias_argc - 1]),
1997                                  target_cmd, class_alias, a_opts.abbrev_flag,
1998                                  c_command->subcommands);
1999     }
2000
2001   gdb_assert (alias_cmd != nullptr);
2002   gdb_assert (alias_cmd->default_args.empty ());
2003   if (default_args != nullptr)
2004     {
2005       default_args = skip_spaces (default_args);
2006
2007       alias_cmd->default_args = default_args;
2008     }
2009 }
2010 \f
2011 /* Print the file / line number / symbol name of the location
2012    specified by SAL.  */
2013
2014 static void
2015 print_sal_location (const symtab_and_line &sal)
2016 {
2017   scoped_restore_current_program_space restore_pspace;
2018   set_current_program_space (sal.pspace);
2019
2020   const char *sym_name = NULL;
2021   if (sal.symbol != NULL)
2022     sym_name = sal.symbol->print_name ();
2023   gdb_printf (_("file: \"%s\", line number: %d, symbol: \"%s\"\n"),
2024               symtab_to_filename_for_display (sal.symtab),
2025               sal.line, sym_name != NULL ? sym_name : "???");
2026 }
2027
2028 /* Print a list of files and line numbers which a user may choose from
2029    in order to list a function which was specified ambiguously (as
2030    with `list classname::overloadedfuncname', for example).  The SALS
2031    array provides the filenames and line numbers.  FORMAT is a
2032    printf-style format string used to tell the user what was
2033    ambiguous.  */
2034
2035 static void
2036 ambiguous_line_spec (gdb::array_view<const symtab_and_line> sals,
2037                      const char *format, ...)
2038 {
2039   va_list ap;
2040   va_start (ap, format);
2041   gdb_vprintf (format, ap);
2042   va_end (ap);
2043
2044   for (const auto &sal : sals)
2045     print_sal_location (sal);
2046 }
2047
2048 /* Comparison function for filter_sals.  Returns a qsort-style
2049    result.  */
2050
2051 static int
2052 cmp_symtabs (const symtab_and_line &sala, const symtab_and_line &salb)
2053 {
2054   const char *dira = sala.symtab->dirname ();
2055   const char *dirb = salb.symtab->dirname ();
2056   int r;
2057
2058   if (dira == NULL)
2059     {
2060       if (dirb != NULL)
2061         return -1;
2062     }
2063   else if (dirb == NULL)
2064     {
2065       if (dira != NULL)
2066         return 1;
2067     }
2068   else
2069     {
2070       r = filename_cmp (dira, dirb);
2071       if (r)
2072         return r;
2073     }
2074
2075   r = filename_cmp (sala.symtab->filename, salb.symtab->filename);
2076   if (r)
2077     return r;
2078
2079   if (sala.line < salb.line)
2080     return -1;
2081   return sala.line == salb.line ? 0 : 1;
2082 }
2083
2084 /* Remove any SALs that do not match the current program space, or
2085    which appear to be "file:line" duplicates.  */
2086
2087 static void
2088 filter_sals (std::vector<symtab_and_line> &sals)
2089 {
2090   /* Remove SALs that do not match.  */
2091   auto from = std::remove_if (sals.begin (), sals.end (),
2092                               [&] (const symtab_and_line &sal)
2093     { return (sal.pspace != current_program_space || sal.symtab == NULL); });
2094
2095   /* Remove dups.  */
2096   std::sort (sals.begin (), from,
2097              [] (const symtab_and_line &sala, const symtab_and_line &salb)
2098    { return cmp_symtabs (sala, salb) < 0; });
2099
2100   from = std::unique (sals.begin (), from,
2101                       [&] (const symtab_and_line &sala,
2102                            const symtab_and_line &salb)
2103     { return cmp_symtabs (sala, salb) == 0; });
2104
2105   sals.erase (from, sals.end ());
2106 }
2107
2108 void
2109 init_cmd_lists (void)
2110 {
2111   max_user_call_depth = 1024;
2112 }
2113
2114 static void
2115 show_info_verbose (struct ui_file *file, int from_tty,
2116                    struct cmd_list_element *c,
2117                    const char *value)
2118 {
2119   if (info_verbose)
2120     gdb_printf (file,
2121                 _("Verbose printing of informational messages is %s.\n"),
2122                 value);
2123   else
2124     gdb_printf (file, _("Verbosity is %s.\n"), value);
2125 }
2126
2127 static void
2128 show_history_expansion_p (struct ui_file *file, int from_tty,
2129                           struct cmd_list_element *c, const char *value)
2130 {
2131   gdb_printf (file, _("History expansion on command input is %s.\n"),
2132               value);
2133 }
2134
2135 static void
2136 show_max_user_call_depth (struct ui_file *file, int from_tty,
2137                           struct cmd_list_element *c, const char *value)
2138 {
2139   gdb_printf (file,
2140               _("The max call depth for user-defined commands is %s.\n"),
2141               value);
2142 }
2143
2144 /* Implement 'show suppress-cli-notifications'.  */
2145
2146 static void
2147 show_suppress_cli_notifications (ui_file *file, int from_tty,
2148                                  cmd_list_element *c, const char *value)
2149 {
2150   gdb_printf (file, _("Suppression of printing CLI notifications "
2151                       "is %s.\n"), value);
2152 }
2153
2154 /* Implement 'set suppress-cli-notifications'.  */
2155
2156 static void
2157 set_suppress_cli_notifications (const char *args, int from_tty,
2158                                 cmd_list_element *c)
2159 {
2160   cli_suppress_notification.user_selected_context
2161     = user_wants_cli_suppress_notification;
2162   cli_suppress_notification.normal_stop
2163     = user_wants_cli_suppress_notification;
2164 }
2165
2166 /* Returns the cmd_list_element in SHOWLIST corresponding to the first
2167    argument of ARGV, which must contain one single value.
2168    Throws an error if no value provided, or value not correct.
2169    FNNAME is used in the error message.  */
2170
2171 static cmd_list_element *
2172 setting_cmd (const char *fnname, struct cmd_list_element *showlist,
2173              int argc, struct value **argv)
2174 {
2175   if (argc == 0)
2176     error (_("You must provide an argument to %s"), fnname);
2177   if (argc != 1)
2178     error (_("You can only provide one argument to %s"), fnname);
2179
2180   struct type *type0 = check_typedef (value_type (argv[0]));
2181
2182   if (type0->code () != TYPE_CODE_ARRAY
2183       && type0->code () != TYPE_CODE_STRING)
2184     error (_("First argument of %s must be a string."), fnname);
2185
2186   const char *a0 = (const char *) value_contents (argv[0]).data ();
2187   cmd_list_element *cmd = lookup_cmd (&a0, showlist, "", NULL, -1, 0);
2188
2189   if (cmd == nullptr || cmd->type != show_cmd)
2190     error (_("First argument of %s must be a "
2191              "valid setting of the 'show' command."), fnname);
2192
2193   return cmd;
2194 }
2195
2196 /* Builds a value from the show CMD.  */
2197
2198 static struct value *
2199 value_from_setting (const setting &var, struct gdbarch *gdbarch)
2200 {
2201   switch (var.type ())
2202     {
2203     case var_integer:
2204       if (var.get<int> () == INT_MAX)
2205         return value_from_longest (builtin_type (gdbarch)->builtin_int,
2206                                    0);
2207       else
2208         return value_from_longest (builtin_type (gdbarch)->builtin_int,
2209                                    var.get<int> ());
2210     case var_zinteger:
2211       return value_from_longest (builtin_type (gdbarch)->builtin_int,
2212                                  var.get<int> ());
2213     case var_boolean:
2214       return value_from_longest (builtin_type (gdbarch)->builtin_int,
2215                                  var.get<bool> () ? 1 : 0);
2216     case var_zuinteger_unlimited:
2217       return value_from_longest (builtin_type (gdbarch)->builtin_int,
2218                                  var.get<int> ());
2219     case var_auto_boolean:
2220       {
2221         int val;
2222
2223         switch (var.get<enum auto_boolean> ())
2224           {
2225           case AUTO_BOOLEAN_TRUE:
2226             val = 1;
2227             break;
2228           case AUTO_BOOLEAN_FALSE:
2229             val = 0;
2230             break;
2231           case AUTO_BOOLEAN_AUTO:
2232             val = -1;
2233             break;
2234           default:
2235             gdb_assert_not_reached ("invalid var_auto_boolean");
2236           }
2237         return value_from_longest (builtin_type (gdbarch)->builtin_int,
2238                                    val);
2239       }
2240     case var_uinteger:
2241       if (var.get<unsigned int> () == UINT_MAX)
2242         return value_from_ulongest
2243           (builtin_type (gdbarch)->builtin_unsigned_int, 0);
2244       else
2245         return value_from_ulongest
2246           (builtin_type (gdbarch)->builtin_unsigned_int,
2247            var.get<unsigned int> ());
2248     case var_zuinteger:
2249       return value_from_ulongest (builtin_type (gdbarch)->builtin_unsigned_int,
2250                                   var.get<unsigned int> ());
2251     case var_string:
2252     case var_string_noescape:
2253     case var_optional_filename:
2254     case var_filename:
2255     case var_enum:
2256       {
2257         const char *value;
2258         size_t len;
2259         if (var.type () == var_enum)
2260           {
2261             value = var.get<const char *> ();
2262             len = strlen (value);
2263           }
2264         else
2265           {
2266             const std::string &st = var.get<std::string> ();
2267             value = st.c_str ();
2268             len = st.length ();
2269           }
2270
2271         if (len > 0)
2272           return value_cstring (value, len,
2273                                 builtin_type (gdbarch)->builtin_char);
2274         else
2275           return value_cstring ("", 1,
2276                                 builtin_type (gdbarch)->builtin_char);
2277       }
2278     default:
2279       gdb_assert_not_reached ("bad var_type");
2280     }
2281 }
2282
2283 /* Implementation of the convenience function $_gdb_setting.  */
2284
2285 static struct value *
2286 gdb_setting_internal_fn (struct gdbarch *gdbarch,
2287                          const struct language_defn *language,
2288                          void *cookie, int argc, struct value **argv)
2289 {
2290   cmd_list_element *show_cmd
2291     = setting_cmd ("$_gdb_setting", showlist, argc, argv);
2292
2293   gdb_assert (show_cmd->var.has_value ());
2294
2295   return value_from_setting (*show_cmd->var, gdbarch);
2296 }
2297
2298 /* Implementation of the convenience function $_gdb_maint_setting.  */
2299
2300 static struct value *
2301 gdb_maint_setting_internal_fn (struct gdbarch *gdbarch,
2302                                const struct language_defn *language,
2303                                void *cookie, int argc, struct value **argv)
2304 {
2305   cmd_list_element *show_cmd
2306     = setting_cmd ("$_gdb_maint_setting", maintenance_show_cmdlist, argc, argv);
2307
2308   gdb_assert (show_cmd->var.has_value ());
2309
2310   return value_from_setting (*show_cmd->var, gdbarch);
2311 }
2312
2313 /* Builds a string value from the show CMD.  */
2314
2315 static struct value *
2316 str_value_from_setting (const setting &var, struct gdbarch *gdbarch)
2317 {
2318   switch (var.type ())
2319     {
2320     case var_integer:
2321     case var_zinteger:
2322     case var_boolean:
2323     case var_zuinteger_unlimited:
2324     case var_auto_boolean:
2325     case var_uinteger:
2326     case var_zuinteger:
2327       {
2328         std::string cmd_val = get_setshow_command_value_string (var);
2329
2330         return value_cstring (cmd_val.c_str (), cmd_val.size (),
2331                               builtin_type (gdbarch)->builtin_char);
2332       }
2333
2334     case var_string:
2335     case var_string_noescape:
2336     case var_optional_filename:
2337     case var_filename:
2338     case var_enum:
2339       /* For these cases, we do not use get_setshow_command_value_string,
2340          as this function handle some characters specially, e.g. by
2341          escaping quotevar.  So, we directly use the var string value,
2342          similarly to the value_from_setting code for these casevar.  */
2343       {
2344         const char *value;
2345         size_t len;
2346         if (var.type () == var_enum)
2347           {
2348             value = var.get<const char *> ();
2349             len = strlen (value);
2350           }
2351         else
2352           {
2353             const std::string &st = var.get<std::string> ();
2354             value = st.c_str ();
2355             len = st.length ();
2356           }
2357
2358         if (len > 0)
2359           return value_cstring (value, len,
2360                                 builtin_type (gdbarch)->builtin_char);
2361         else
2362           return value_cstring ("", 1,
2363                                 builtin_type (gdbarch)->builtin_char);
2364       }
2365     default:
2366       gdb_assert_not_reached ("bad var_type");
2367     }
2368 }
2369
2370 /* Implementation of the convenience function $_gdb_setting_str.  */
2371
2372 static struct value *
2373 gdb_setting_str_internal_fn (struct gdbarch *gdbarch,
2374                              const struct language_defn *language,
2375                              void *cookie, int argc, struct value **argv)
2376 {
2377   cmd_list_element *show_cmd
2378     = setting_cmd ("$_gdb_setting_str", showlist, argc, argv);
2379
2380   gdb_assert (show_cmd->var.has_value ());
2381
2382   return str_value_from_setting (*show_cmd->var, gdbarch);
2383 }
2384
2385
2386 /* Implementation of the convenience function $_gdb_maint_setting_str.  */
2387
2388 static struct value *
2389 gdb_maint_setting_str_internal_fn (struct gdbarch *gdbarch,
2390                                    const struct language_defn *language,
2391                                    void *cookie, int argc, struct value **argv)
2392 {
2393   cmd_list_element *show_cmd
2394     = setting_cmd ("$_gdb_maint_setting_str", maintenance_show_cmdlist, argc,
2395                    argv);
2396
2397   gdb_assert (show_cmd->var.has_value ());
2398
2399   return str_value_from_setting (*show_cmd->var, gdbarch);
2400 }
2401
2402 void _initialize_cli_cmds ();
2403 void
2404 _initialize_cli_cmds ()
2405 {
2406   struct cmd_list_element *c;
2407
2408   /* Define the classes of commands.
2409      They will appear in the help list in alphabetical order.  */
2410
2411   add_cmd ("internals", class_maintenance, _("\
2412 Maintenance commands.\n\
2413 Some gdb commands are provided just for use by gdb maintainers.\n\
2414 These commands are subject to frequent change, and may not be as\n\
2415 well documented as user commands."),
2416            &cmdlist);
2417   add_cmd ("obscure", class_obscure, _("Obscure features."), &cmdlist);
2418   add_cmd ("aliases", class_alias,
2419            _("User-defined aliases of other commands."), &cmdlist);
2420   add_cmd ("user-defined", class_user, _("\
2421 User-defined commands.\n\
2422 The commands in this class are those defined by the user.\n\
2423 Use the \"define\" command to define a command."), &cmdlist);
2424   add_cmd ("support", class_support, _("Support facilities."), &cmdlist);
2425   if (!dbx_commands)
2426     add_cmd ("status", class_info, _("Status inquiries."), &cmdlist);
2427   add_cmd ("files", class_files, _("Specifying and examining files."),
2428            &cmdlist);
2429   add_cmd ("breakpoints", class_breakpoint,
2430            _("Making program stop at certain points."), &cmdlist);
2431   add_cmd ("data", class_vars, _("Examining data."), &cmdlist);
2432   add_cmd ("stack", class_stack, _("\
2433 Examining the stack.\n\
2434 The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
2435 counting from zero for the innermost (currently executing) frame.\n\n\
2436 At any time gdb identifies one frame as the \"selected\" frame.\n\
2437 Variable lookups are done with respect to the selected frame.\n\
2438 When the program being debugged stops, gdb selects the innermost frame.\n\
2439 The commands below can be used to select other frames by number or address."),
2440            &cmdlist);
2441 #ifdef TUI
2442   add_cmd ("text-user-interface", class_tui,
2443            _("TUI is the GDB text based interface.\n\
2444 In TUI mode, GDB can display several text windows showing\n\
2445 the source file, the processor registers, the program disassembly, ..."), &cmdlist);
2446 #endif
2447   add_cmd ("running", class_run, _("Running the program."), &cmdlist);
2448
2449   /* Define general commands.  */
2450
2451   add_com ("pwd", class_files, pwd_command, _("\
2452 Print working directory.\n\
2453 This is used for your program as well."));
2454
2455   c = add_cmd ("cd", class_files, cd_command, _("\
2456 Set working directory to DIR for debugger.\n\
2457 The debugger's current working directory specifies where scripts and other\n\
2458 files that can be loaded by GDB are located.\n\
2459 In order to change the inferior's current working directory, the recommended\n\
2460 way is to use the \"set cwd\" command."), &cmdlist);
2461   set_cmd_completer (c, filename_completer);
2462
2463   add_com ("echo", class_support, echo_command, _("\
2464 Print a constant string.  Give string as argument.\n\
2465 C escape sequences may be used in the argument.\n\
2466 No newline is added at the end of the argument;\n\
2467 use \"\\n\" if you want a newline to be printed.\n\
2468 Since leading and trailing whitespace are ignored in command arguments,\n\
2469 if you want to print some you must use \"\\\" before leading whitespace\n\
2470 to be printed or after trailing whitespace."));
2471
2472   add_setshow_enum_cmd ("script-extension", class_support,
2473                         script_ext_enums, &script_ext_mode, _("\
2474 Set mode for script filename extension recognition."), _("\
2475 Show mode for script filename extension recognition."), _("\
2476 off  == no filename extension recognition (all sourced files are GDB scripts)\n\
2477 soft == evaluate script according to filename extension, fallback to GDB script"
2478   "\n\
2479 strict == evaluate script according to filename extension, error if not supported"
2480   ),
2481                         NULL,
2482                         show_script_ext_mode,
2483                         &setlist, &showlist);
2484
2485   cmd_list_element *quit_cmd
2486     = add_com ("quit", class_support, quit_command, _("\
2487 Exit gdb.\n\
2488 Usage: quit [EXPR] or exit [EXPR]\n\
2489 The optional expression EXPR, if present, is evaluated and the result\n\
2490 used as GDB's exit code.  The default is zero."));
2491   cmd_list_element *help_cmd
2492     = add_com ("help", class_support, help_command,
2493                _("Print list of commands."));
2494   set_cmd_completer (help_cmd, command_completer);
2495   add_com_alias ("q", quit_cmd, class_support, 1);
2496   add_com_alias ("exit", quit_cmd, class_support, 1);
2497   add_com_alias ("h", help_cmd, class_support, 1);
2498
2499   add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\
2500 Set verbosity."), _("\
2501 Show verbosity."), NULL,
2502                            set_verbose,
2503                            show_info_verbose,
2504                            &setlist, &showlist);
2505
2506   add_setshow_prefix_cmd
2507     ("history", class_support,
2508      _("Generic command for setting command history parameters."),
2509      _("Generic command for showing command history parameters."),
2510      &sethistlist, &showhistlist, &setlist, &showlist);
2511
2512   add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\
2513 Set history expansion on command input."), _("\
2514 Show history expansion on command input."), _("\
2515 Without an argument, history expansion is enabled."),
2516                            NULL,
2517                            show_history_expansion_p,
2518                            &sethistlist, &showhistlist);
2519
2520   cmd_list_element *info_cmd
2521     = add_prefix_cmd ("info", class_info, info_command, _("\
2522 Generic command for showing things about the program being debugged."),
2523                       &infolist, 0, &cmdlist);
2524   add_com_alias ("i", info_cmd, class_info, 1);
2525   add_com_alias ("inf", info_cmd, class_info, 1);
2526
2527   add_com ("complete", class_obscure, complete_command,
2528            _("List the completions for the rest of the line as a command."));
2529
2530   c = add_show_prefix_cmd ("show", class_info, _("\
2531 Generic command for showing things about the debugger."),
2532                            &showlist, 0, &cmdlist);
2533   /* Another way to get at the same thing.  */
2534   add_alias_cmd ("set", c, class_info, 0, &infolist);
2535
2536   cmd_list_element *with_cmd
2537     = add_com ("with", class_vars, with_command, _("\
2538 Temporarily set SETTING to VALUE, run COMMAND, and restore SETTING.\n\
2539 Usage: with SETTING [VALUE] [-- COMMAND]\n\
2540 Usage: w SETTING [VALUE] [-- COMMAND]\n\
2541 With no COMMAND, repeats the last executed command.\n\
2542 \n\
2543 SETTING is any setting you can change with the \"set\" subcommands.\n\
2544 E.g.:\n\
2545   with language pascal -- print obj\n\
2546   with print elements unlimited -- print obj\n\
2547 \n\
2548 You can change multiple settings using nested with, and use\n\
2549 abbreviations for commands and/or values.  E.g.:\n\
2550   w la p -- w p el u -- p obj"));
2551   set_cmd_completer_handle_brkchars (with_cmd, with_command_completer);
2552   add_com_alias ("w", with_cmd, class_vars, 1);
2553
2554   add_internal_function ("_gdb_setting_str", _("\
2555 $_gdb_setting_str - returns the value of a GDB setting as a string.\n\
2556 Usage: $_gdb_setting_str (setting)\n\
2557 \n\
2558 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2559 boolean values are \"off\", \"on\".\n\
2560 Some integer settings accept an unlimited value, returned\n\
2561 as \"unlimited\"."),
2562                          gdb_setting_str_internal_fn, NULL);
2563
2564   add_internal_function ("_gdb_setting", _("\
2565 $_gdb_setting - returns the value of a GDB setting.\n\
2566 Usage: $_gdb_setting (setting)\n\
2567 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2568 boolean values are \"off\", \"on\".\n\
2569 Some integer settings accept an unlimited value, returned\n\
2570 as 0 or -1 depending on the setting."),
2571                          gdb_setting_internal_fn, NULL);
2572
2573   add_internal_function ("_gdb_maint_setting_str", _("\
2574 $_gdb_maint_setting_str - returns the value of a GDB maintenance setting as a string.\n\
2575 Usage: $_gdb_maint_setting_str (setting)\n\
2576 \n\
2577 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2578 boolean values are \"off\", \"on\".\n\
2579 Some integer settings accept an unlimited value, returned\n\
2580 as \"unlimited\"."),
2581                          gdb_maint_setting_str_internal_fn, NULL);
2582
2583   add_internal_function ("_gdb_maint_setting", _("\
2584 $_gdb_maint_setting - returns the value of a GDB maintenance setting.\n\
2585 Usage: $_gdb_maint_setting (setting)\n\
2586 auto-boolean values are \"off\", \"on\", \"auto\".\n\
2587 boolean values are \"off\", \"on\".\n\
2588 Some integer settings accept an unlimited value, returned\n\
2589 as 0 or -1 depending on the setting."),
2590                          gdb_maint_setting_internal_fn, NULL);
2591
2592   add_cmd ("commands", no_set_class, show_commands, _("\
2593 Show the history of commands you typed.\n\
2594 You can supply a command number to start with, or a `+' to start after\n\
2595 the previous command number shown."),
2596            &showlist);
2597
2598   add_cmd ("version", no_set_class, show_version,
2599            _("Show what version of GDB this is."), &showlist);
2600
2601   add_cmd ("configuration", no_set_class, show_configuration,
2602            _("Show how GDB was configured at build time."), &showlist);
2603
2604   add_setshow_prefix_cmd ("debug", no_class,
2605                           _("Generic command for setting gdb debugging flags."),
2606                           _("Generic command for showing gdb debugging flags."),
2607                           &setdebuglist, &showdebuglist,
2608                           &setlist, &showlist);
2609
2610   cmd_list_element *shell_cmd
2611     = add_com ("shell", class_support, shell_command, _("\
2612 Execute the rest of the line as a shell command.\n\
2613 With no arguments, run an inferior shell."));
2614   set_cmd_completer (shell_cmd, filename_completer);
2615
2616   add_com_alias ("!", shell_cmd, class_support, 0);
2617
2618   c = add_com ("edit", class_files, edit_command, _("\
2619 Edit specified file or function.\n\
2620 With no argument, edits file containing most recent line listed.\n\
2621 Editing targets can be specified in these ways:\n\
2622   FILE:LINENUM, to edit at that line in that file,\n\
2623   FUNCTION, to edit at the beginning of that function,\n\
2624   FILE:FUNCTION, to distinguish among like-named static functions.\n\
2625   *ADDRESS, to edit at the line containing that address.\n\
2626 Uses EDITOR environment variable contents as editor (or ex as default)."));
2627
2628   c->completer = location_completer;
2629
2630   cmd_list_element *pipe_cmd
2631     = add_com ("pipe", class_support, pipe_command, _("\
2632 Send the output of a gdb command to a shell command.\n\
2633 Usage: | [COMMAND] | SHELL_COMMAND\n\
2634 Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2635 Usage: pipe [COMMAND] | SHELL_COMMAND\n\
2636 Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
2637 \n\
2638 Executes COMMAND and sends its output to SHELL_COMMAND.\n\
2639 \n\
2640 The -d option indicates to use the string DELIM to separate COMMAND\n\
2641 from SHELL_COMMAND, in alternative to |.  This is useful in\n\
2642 case COMMAND contains a | character.\n\
2643 \n\
2644 With no COMMAND, repeat the last executed command\n\
2645 and send its output to SHELL_COMMAND."));
2646   set_cmd_completer_handle_brkchars (pipe_cmd, pipe_command_completer);
2647   add_com_alias ("|", pipe_cmd, class_support, 0);
2648
2649   cmd_list_element *list_cmd
2650     = add_com ("list", class_files, list_command, _("\
2651 List specified function or line.\n\
2652 With no argument, lists ten more lines after or around previous listing.\n\
2653 \"list -\" lists the ten lines before a previous ten-line listing.\n\
2654 One argument specifies a line, and ten lines are listed around that line.\n\
2655 Two arguments with comma between specify starting and ending lines to list.\n\
2656 Lines can be specified in these ways:\n\
2657   LINENUM, to list around that line in current file,\n\
2658   FILE:LINENUM, to list around that line in that file,\n\
2659   FUNCTION, to list around beginning of that function,\n\
2660   FILE:FUNCTION, to distinguish among like-named static functions.\n\
2661   *ADDRESS, to list around the line containing that address.\n\
2662 With two args, if one is empty, it stands for ten lines away from\n\
2663 the other arg.\n\
2664 \n\
2665 By default, when a single location is given, display ten lines.\n\
2666 This can be changed using \"set listsize\", and the current value\n\
2667 can be shown using \"show listsize\"."));
2668
2669   add_com_alias ("l", list_cmd, class_files, 1);
2670
2671   if (dbx_commands)
2672     add_com_alias ("file", list_cmd, class_files, 1);
2673
2674   c = add_com ("disassemble", class_vars, disassemble_command, _("\
2675 Disassemble a specified section of memory.\n\
2676 Usage: disassemble[/m|/r|/s] START [, END]\n\
2677 Default is the function surrounding the pc of the selected frame.\n\
2678 \n\
2679 With a /s modifier, source lines are included (if available).\n\
2680 In this mode, the output is displayed in PC address order, and\n\
2681 file names and contents for all relevant source files are displayed.\n\
2682 \n\
2683 With a /m modifier, source lines are included (if available).\n\
2684 This view is \"source centric\": the output is in source line order,\n\
2685 regardless of any optimization that is present.  Only the main source file\n\
2686 is displayed, not those of, e.g., any inlined functions.\n\
2687 This modifier hasn't proved useful in practice and is deprecated\n\
2688 in favor of /s.\n\
2689 \n\
2690 With a /r modifier, raw instructions in hex are included.\n\
2691 \n\
2692 With a single argument, the function surrounding that address is dumped.\n\
2693 Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
2694   in the form of \"start,end\", or \"start,+length\".\n\
2695 \n\
2696 Note that the address is interpreted as an expression, not as a location\n\
2697 like in the \"break\" command.\n\
2698 So, for example, if you want to disassemble function bar in file foo.c\n\
2699 you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
2700   set_cmd_completer (c, location_completer);
2701
2702   c = add_com ("make", class_support, make_command, _("\
2703 Run the ``make'' program using the rest of the line as arguments."));
2704   set_cmd_completer (c, filename_completer);
2705   c = add_cmd ("user", no_class, show_user, _("\
2706 Show definitions of non-python/scheme user defined commands.\n\
2707 Argument is the name of the user defined command.\n\
2708 With no argument, show definitions of all user defined commands."), &showlist);
2709   set_cmd_completer (c, show_user_completer);
2710   add_com ("apropos", class_support, apropos_command, _("\
2711 Search for commands matching a REGEXP.\n\
2712 Usage: apropos [-v] REGEXP\n\
2713 Flag -v indicates to produce a verbose output, showing full documentation\n\
2714 of the matching commands."));
2715
2716   add_setshow_uinteger_cmd ("max-user-call-depth", no_class,
2717                            &max_user_call_depth, _("\
2718 Set the max call depth for non-python/scheme user-defined commands."), _("\
2719 Show the max call depth for non-python/scheme user-defined commands."), NULL,
2720                             NULL,
2721                             show_max_user_call_depth,
2722                             &setlist, &showlist);
2723
2724   add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
2725 Set tracing of GDB CLI commands."), _("\
2726 Show state of GDB CLI command tracing."), _("\
2727 When 'on', each command is displayed as it is executed."),
2728                            NULL,
2729                            NULL,
2730                            &setlist, &showlist);
2731
2732   const auto alias_opts = make_alias_options_def_group (nullptr);
2733
2734   static std::string alias_help
2735     = gdb::option::build_help (_("\
2736 Define a new command that is an alias of an existing command.\n\
2737 Usage: alias [-a] [--] ALIAS = COMMAND [DEFAULT-ARGS...]\n\
2738 ALIAS is the name of the alias command to create.\n\
2739 COMMAND is the command being aliased to.\n\
2740 \n\
2741 Options:\n\
2742 %OPTIONS%\n\
2743 \n\
2744 GDB will automatically prepend the provided DEFAULT-ARGS to the list\n\
2745 of arguments explicitly provided when using ALIAS.\n\
2746 Use \"help aliases\" to list all user defined aliases and their default args.\n\
2747 \n\
2748 Examples:\n\
2749 Make \"spe\" an alias of \"set print elements\":\n\
2750   alias spe = set print elements\n\
2751 Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
2752   alias -a set print elms = set print elements\n\
2753 Make \"btf\" an alias of \"backtrace -full -past-entry -past-main\" :\n\
2754   alias btf = backtrace -full -past-entry -past-main\n\
2755 Make \"wLapPeu\" an alias of 2 nested \"with\":\n\
2756   alias wLapPeu = with language pascal -- with print elements unlimited --"),
2757                                alias_opts);
2758
2759   c = add_com ("alias", class_support, alias_command,
2760                alias_help.c_str ());
2761
2762   set_cmd_completer_handle_brkchars (c, alias_command_completer);
2763
2764   add_setshow_boolean_cmd ("suppress-cli-notifications", no_class,
2765                            &user_wants_cli_suppress_notification,
2766                            _("\
2767 Set whether printing notifications on CLI is suppressed."), _("\
2768 Show whether printing notifications on CLI is suppressed."), _("\
2769 When on, printing notifications (such as inferior/thread switch)\n\
2770 on CLI is suppressed."),
2771                            set_suppress_cli_notifications,
2772                            show_suppress_cli_notifications,
2773                            &setlist,
2774                            &showlist);
2775
2776   const char *source_help_text = xstrprintf (_("\
2777 Read commands from a file named FILE.\n\
2778 \n\
2779 Usage: source [-s] [-v] FILE\n\
2780 -s: search for the script in the source search path,\n\
2781     even if FILE contains directories.\n\
2782 -v: each command in FILE is echoed as it is executed.\n\
2783 \n\
2784 Note that the file \"%s\" is read automatically in this way\n\
2785 when GDB is started."), GDBINIT).release ();
2786   c = add_cmd ("source", class_support, source_command,
2787                source_help_text, &cmdlist);
2788   set_cmd_completer (c, filename_completer);
2789 }
This page took 0.187825 seconds and 4 git commands to generate.