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