gdb/cli/cli-cmds.c

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