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