1/* GDB CLI commands. 2 3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21#include "defs.h" 22#include "readline/readline.h" 23#include "readline/tilde.h" 24#include "completer.h" 25#include "target.h" /* For baud_rate, remote_debug and remote_timeout */ 26#include "gdb_wait.h" /* For shell escape implementation */ 27#include "gdb_regex.h" /* Used by apropos_command */ 28#include "gdb_string.h" 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 40#include "ui-out.h" 41 42#include "top.h" 43#include "cli/cli-decode.h" 44#include "cli/cli-script.h" 45#include "cli/cli-setshow.h" 46#include "cli/cli-cmds.h" 47 48#ifdef TUI 49#include "tui/tui.h" /* For tui_active et.al. */ 50#endif 51 52#include <fcntl.h> 53 54/* Prototypes for local command functions */ 55 56static void complete_command (char *, int); 57 58static void echo_command (char *, int); 59 60static void pwd_command (char *, int); 61 62static void show_version (char *, int); 63 64static void help_command (char *, int); 65 66static void show_command (char *, int); 67 68static void info_command (char *, int); 69 70static void show_debug (char *, int); 71 72static void set_debug (char *, int); 73 74static void show_user (char *, int); 75 76static void make_command (char *, int); 77 78static void shell_escape (char *, int); 79 80static void edit_command (char *, int); 81 82static void list_command (char *, int); 83 84void apropos_command (char *, int); 85 86/* Prototypes for local utility functions */ 87 88static void ambiguous_line_spec (struct symtabs_and_lines *); 89 90/* Limit the call depth of user-defined commands */ 91int max_user_call_depth; 92 93/* Define all cmd_list_elements. */ 94 95/* Chain containing all defined commands. */ 96 97struct cmd_list_element *cmdlist; 98 99/* Chain containing all defined info subcommands. */ 100 101struct cmd_list_element *infolist; 102 103/* Chain containing all defined enable subcommands. */ 104 105struct cmd_list_element *enablelist; 106 107/* Chain containing all defined disable subcommands. */ 108 109struct cmd_list_element *disablelist; 110 111/* Chain containing all defined toggle subcommands. */ 112 113struct cmd_list_element *togglelist; 114 115/* Chain containing all defined stop subcommands. */ 116 117struct cmd_list_element *stoplist; 118 119/* Chain containing all defined delete subcommands. */ 120 121struct cmd_list_element *deletelist; 122 123/* Chain containing all defined detach subcommands. */ 124 125struct cmd_list_element *detachlist; 126 127/* Chain containing all defined "enable breakpoint" subcommands. */ 128 129struct cmd_list_element *enablebreaklist; 130 131/* Chain containing all defined set subcommands */ 132 133struct cmd_list_element *setlist; 134 135/* Chain containing all defined unset subcommands */ 136 137struct cmd_list_element *unsetlist; 138 139/* Chain containing all defined show subcommands. */ 140 141struct cmd_list_element *showlist; 142 143/* Chain containing all defined \"set history\". */ 144 145struct cmd_list_element *sethistlist; 146 147/* Chain containing all defined \"show history\". */ 148 149struct cmd_list_element *showhistlist; 150 151/* Chain containing all defined \"unset history\". */ 152 153struct cmd_list_element *unsethistlist; 154 155/* Chain containing all defined maintenance subcommands. */ 156 157struct cmd_list_element *maintenancelist; 158 159/* Chain containing all defined "maintenance info" subcommands. */ 160 161struct cmd_list_element *maintenanceinfolist; 162 163/* Chain containing all defined "maintenance print" subcommands. */ 164 165struct cmd_list_element *maintenanceprintlist; 166 167struct cmd_list_element *setprintlist; 168 169struct cmd_list_element *showprintlist; 170 171struct cmd_list_element *setdebuglist; 172 173struct cmd_list_element *showdebuglist; 174 175struct cmd_list_element *setchecklist; 176 177struct cmd_list_element *showchecklist; 178 179/* Command tracing state. */ 180 181int source_verbose = 0; 182int trace_commands = 0; 183 184/* Utility used everywhere when at least one argument is needed and 185 none is supplied. */ 186 187void 188error_no_arg (char *why) 189{ 190 error (_("Argument required (%s)."), why); 191} 192 193/* The "info" command is defined as a prefix, with allow_unknown = 0. 194 Therefore, its own definition is called only for "info" with no args. */ 195 196static void 197info_command (char *arg, int from_tty) 198{ 199 printf_unfiltered (_("\"info\" must be followed by the name of an info command.\n")); 200 help_list (infolist, "info ", -1, gdb_stdout); 201} 202 203/* The "show" command with no arguments shows all the settings. */ 204 205static void 206show_command (char *arg, int from_tty) 207{ 208 cmd_show_list (showlist, from_tty, ""); 209} 210 211/* Provide documentation on command or list given by COMMAND. FROM_TTY 212 is ignored. */ 213 214static void 215help_command (char *command, int from_tty) 216{ 217 help_cmd (command, gdb_stdout); 218} 219 220/* String compare function for qsort. */ 221static int 222compare_strings (const void *arg1, const void *arg2) 223{ 224 const char **s1 = (const char **) arg1; 225 const char **s2 = (const char **) arg2; 226 return strcmp (*s1, *s2); 227} 228 229/* The "complete" command is used by Emacs to implement completion. */ 230 231static void 232complete_command (char *arg, int from_tty) 233{ 234 int i; 235 int argpoint; 236 char **completions, *point, *arg_prefix; 237 238 dont_repeat (); 239 240 if (arg == NULL) 241 arg = ""; 242 argpoint = strlen (arg); 243 244 /* complete_line assumes that its first argument is somewhere within, 245 and except for filenames at the beginning of, the word to be completed. 246 The following crude imitation of readline's word-breaking tries to 247 accomodate this. */ 248 point = arg + argpoint; 249 while (point > arg) 250 { 251 if (strchr (rl_completer_word_break_characters, point[-1]) != 0) 252 break; 253 point--; 254 } 255 256 arg_prefix = alloca (point - arg + 1); 257 memcpy (arg_prefix, arg, point - arg); 258 arg_prefix[point - arg] = 0; 259 260 completions = complete_line (point, arg, argpoint); 261 262 if (completions) 263 { 264 int item, size; 265 266 for (size = 0; completions[size]; ++size) 267 ; 268 qsort (completions, size, sizeof (char *), compare_strings); 269 270 /* We do extra processing here since we only want to print each 271 unique item once. */ 272 item = 0; 273 while (item < size) 274 { 275 int next_item; 276 printf_unfiltered ("%s%s\n", arg_prefix, completions[item]); 277 next_item = item + 1; 278 while (next_item < size 279 && ! strcmp (completions[item], completions[next_item])) 280 { 281 xfree (completions[next_item]); 282 ++next_item; 283 } 284 285 xfree (completions[item]); 286 item = next_item; 287 } 288 289 xfree (completions); 290 } 291} 292 293int 294is_complete_command (struct cmd_list_element *c) 295{ 296 return cmd_cfunc_eq (c, complete_command); 297} 298 299static void 300show_version (char *args, int from_tty) 301{ 302 immediate_quit++; 303 print_gdb_version (gdb_stdout); 304 printf_filtered ("\n"); 305 immediate_quit--; 306} 307 308/* Handle the quit command. */ 309 310void 311quit_command (char *args, int from_tty) 312{ 313 if (!quit_confirm ()) 314 error (_("Not confirmed.")); 315 quit_force (args, from_tty); 316} 317 318static void 319pwd_command (char *args, int from_tty) 320{ 321 if (args) 322 error (_("The \"pwd\" command does not take an argument: %s"), args); 323 getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)); 324 325 if (strcmp (gdb_dirbuf, current_directory) != 0) 326 printf_unfiltered (_("Working directory %s\n (canonically %s).\n"), 327 current_directory, gdb_dirbuf); 328 else 329 printf_unfiltered (_("Working directory %s.\n"), current_directory); 330} 331 332void 333cd_command (char *dir, int from_tty) 334{ 335 int len; 336 /* Found something other than leading repetitions of "/..". */ 337 int found_real_path; 338 char *p; 339 340 /* If the new directory is absolute, repeat is a no-op; if relative, 341 repeat might be useful but is more likely to be a mistake. */ 342 dont_repeat (); 343 344 if (dir == 0) 345 error_no_arg (_("new working directory")); 346 347 dir = tilde_expand (dir); 348 make_cleanup (xfree, dir); 349 350 if (chdir (dir) < 0) 351 perror_with_name (dir); 352 353#ifdef HAVE_DOS_BASED_FILE_SYSTEM 354 /* There's too much mess with DOSish names like "d:", "d:.", 355 "d:./foo" etc. Instead of having lots of special #ifdef'ed code, 356 simply get the canonicalized name of the current directory. */ 357 dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)); 358#endif 359 360 len = strlen (dir); 361 if (IS_DIR_SEPARATOR (dir[len - 1])) 362 { 363 /* Remove the trailing slash unless this is a root directory 364 (including a drive letter on non-Unix systems). */ 365 if (!(len == 1) /* "/" */ 366#ifdef HAVE_DOS_BASED_FILE_SYSTEM 367 && !(len == 3 && dir[1] == ':') /* "d:/" */ 368#endif 369 ) 370 len--; 371 } 372 373 dir = savestring (dir, len); 374 if (IS_ABSOLUTE_PATH (dir)) 375 current_directory = dir; 376 else 377 { 378 if (IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])) 379 current_directory = concat (current_directory, dir, (char *)NULL); 380 else 381 current_directory = concat (current_directory, SLASH_STRING, 382 dir, (char *)NULL); 383 xfree (dir); 384 } 385 386 /* Now simplify any occurrences of `.' and `..' in the pathname. */ 387 388 found_real_path = 0; 389 for (p = current_directory; *p;) 390 { 391 if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' 392 && (p[2] == 0 || IS_DIR_SEPARATOR (p[2]))) 393 strcpy (p, p + 2); 394 else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.' 395 && (p[3] == 0 || IS_DIR_SEPARATOR (p[3]))) 396 { 397 if (found_real_path) 398 { 399 /* Search backwards for the directory just before the "/.." 400 and obliterate it and the "/..". */ 401 char *q = p; 402 while (q != current_directory && !IS_DIR_SEPARATOR (q[-1])) 403 --q; 404 405 if (q == current_directory) 406 /* current_directory is 407 a relative pathname ("can't happen"--leave it alone). */ 408 ++p; 409 else 410 { 411 strcpy (q - 1, p + 3); 412 p = q - 1; 413 } 414 } 415 else 416 /* We are dealing with leading repetitions of "/..", for example 417 "/../..", which is the Mach super-root. */ 418 p += 3; 419 } 420 else 421 { 422 found_real_path = 1; 423 ++p; 424 } 425 } 426 427 forget_cached_source_info (); 428 429 if (from_tty) 430 pwd_command ((char *) 0, 1); 431} 432 433void 434source_script (char *file, int from_tty) 435{ 436 FILE *stream; 437 struct cleanup *old_cleanups; 438 char *full_pathname = NULL; 439 int fd; 440 441 if (file == NULL || *file == 0) 442 { 443 error (_("source command requires file name of file to source.")); 444 } 445 446 file = tilde_expand (file); 447 old_cleanups = make_cleanup (xfree, file); 448 449 /* Search for and open 'file' on the search path used for source 450 files. Put the full location in 'full_pathname'. */ 451 fd = openp (source_path, OPF_TRY_CWD_FIRST, 452 file, O_RDONLY, 0, &full_pathname); 453 454 /* Use the full path name, if it is found. */ 455 if (full_pathname != NULL && fd != -1) 456 { 457 file = full_pathname; 458 } 459 460 if (fd == -1) 461 { 462 if (from_tty) 463 perror_with_name (file); 464 else 465 return; 466 } 467 468 stream = fdopen (fd, FOPEN_RT); 469 script_from_file (stream, file); 470 471 do_cleanups (old_cleanups); 472} 473 474/* Return the source_verbose global variable to its previous state 475 on exit from the source command, by whatever means. */ 476static void 477source_verbose_cleanup (void *old_value) 478{ 479 source_verbose = *(int *)old_value; 480 xfree (old_value); 481} 482 483static void 484source_command (char *args, int from_tty) 485{ 486 struct cleanup *old_cleanups; 487 char *file = args; 488 int *old_source_verbose = xmalloc (sizeof(int)); 489 490 *old_source_verbose = source_verbose; 491 old_cleanups = make_cleanup (source_verbose_cleanup, old_source_verbose); 492 493 /* -v causes the source command to run in verbose mode. 494 We still have to be able to handle filenames with spaces in a 495 backward compatible way, so buildargv is not appropriate. */ 496 497 if (args) 498 { 499 /* Make sure leading white space does not break the comparisons. */ 500 while (isspace(args[0])) 501 args++; 502 503 /* Is -v the first thing in the string? */ 504 if (args[0] == '-' && args[1] == 'v' && isspace (args[2])) 505 { 506 source_verbose = 1; 507 508 /* Trim -v and whitespace from the filename. */ 509 file = &args[3]; 510 while (isspace (file[0])) 511 file++; 512 } 513 } 514 515 source_script (file, from_tty); 516} 517 518 519static void 520echo_command (char *text, int from_tty) 521{ 522 char *p = text; 523 int c; 524 525 if (text) 526 while ((c = *p++) != '\0') 527 { 528 if (c == '\\') 529 { 530 /* \ at end of argument is used after spaces 531 so they won't be lost. */ 532 if (*p == 0) 533 return; 534 535 c = parse_escape (&p); 536 if (c >= 0) 537 printf_filtered ("%c", c); 538 } 539 else 540 printf_filtered ("%c", c); 541 } 542 543 /* Force this output to appear now. */ 544 wrap_here (""); 545 gdb_flush (gdb_stdout); 546} 547 548static void 549shell_escape (char *arg, int from_tty) 550{ 551#if defined(CANT_FORK) || \ 552 (!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK)) 553 /* If ARG is NULL, they want an inferior shell, but `system' just 554 reports if the shell is available when passed a NULL arg. */ 555 int rc = system (arg ? arg : ""); 556 557 if (!arg) 558 arg = "inferior shell"; 559 560 if (rc == -1) 561 { 562 fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg, 563 safe_strerror (errno)); 564 gdb_flush (gdb_stderr); 565 } 566 else if (rc) 567 { 568 fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc); 569 gdb_flush (gdb_stderr); 570 } 571#ifdef GLOBAL_CURDIR 572 /* Make sure to return to the directory GDB thinks it is, in case the 573 shell command we just ran changed it. */ 574 chdir (current_directory); 575#endif 576#else /* Can fork. */ 577 int rc, status, pid; 578 579 if ((pid = vfork ()) == 0) 580 { 581 char *p, *user_shell; 582 583 if ((user_shell = (char *) getenv ("SHELL")) == NULL) 584 user_shell = "/bin/sh"; 585 586 /* Get the name of the shell for arg0 */ 587 if ((p = strrchr (user_shell, '/')) == NULL) 588 p = user_shell; 589 else 590 p++; /* Get past '/' */ 591 592 if (!arg) 593 execl (user_shell, p, (char *) 0); 594 else 595 execl (user_shell, p, "-c", arg, (char *) 0); 596 597 fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell, 598 safe_strerror (errno)); 599 gdb_flush (gdb_stderr); 600 _exit (0177); 601 } 602 603 if (pid != -1) 604 while ((rc = wait (&status)) != pid && rc != -1) 605 ; 606 else 607 error (_("Fork failed")); 608#endif /* Can fork. */ 609} 610 611static void 612edit_command (char *arg, int from_tty) 613{ 614 struct symtabs_and_lines sals; 615 struct symtab_and_line sal; 616 struct symbol *sym; 617 char *arg1; 618 int cmdlen, log10; 619 unsigned m; 620 char *editor; 621 char *p, *fn; 622 623 /* Pull in the current default source line if necessary */ 624 if (arg == 0) 625 { 626 set_default_source_symtab_and_line (); 627 sal = get_current_source_symtab_and_line (); 628 } 629 630 /* bare "edit" edits file with present line. */ 631 632 if (arg == 0) 633 { 634 if (sal.symtab == 0) 635 error (_("No default source file yet.")); 636 sal.line += get_lines_to_list () / 2; 637 } 638 else 639 { 640 641 /* Now should only be one argument -- decode it in SAL */ 642 643 arg1 = arg; 644 sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0); 645 646 if (! sals.nelts) return; /* C++ */ 647 if (sals.nelts > 1) { 648 ambiguous_line_spec (&sals); 649 xfree (sals.sals); 650 return; 651 } 652 653 sal = sals.sals[0]; 654 xfree (sals.sals); 655 656 if (*arg1) 657 error (_("Junk at end of line specification.")); 658 659 /* if line was specified by address, 660 first print exactly which line, and which file. 661 In this case, sal.symtab == 0 means address is outside 662 of all known source files, not that user failed to give a filename. */ 663 if (*arg == '*') 664 { 665 if (sal.symtab == 0) 666 /* FIXME-32x64--assumes sal.pc fits in long. */ 667 error (_("No source file for address %s."), 668 hex_string ((unsigned long) sal.pc)); 669 sym = find_pc_function (sal.pc); 670 if (sym) 671 { 672 deprecated_print_address_numeric (sal.pc, 1, gdb_stdout); 673 printf_filtered (" is in "); 674 fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout); 675 printf_filtered (" (%s:%d).\n", sal.symtab->filename, sal.line); 676 } 677 else 678 { 679 deprecated_print_address_numeric (sal.pc, 1, gdb_stdout); 680 printf_filtered (" is at %s:%d.\n", 681 sal.symtab->filename, sal.line); 682 } 683 } 684 685 /* If what was given does not imply a symtab, it must be an undebuggable 686 symbol which means no source code. */ 687 688 if (sal.symtab == 0) 689 error (_("No line number known for %s."), arg); 690 } 691 692 if ((editor = (char *) getenv ("EDITOR")) == NULL) 693 editor = "/bin/ex"; 694 695 /* Approximate base-10 log of line to 1 unit for digit count */ 696 for(log10=32, m=0x80000000; !(sal.line & m) && log10>0; log10--, m=m>>1); 697 log10 = 1 + (int)((log10 + (0 == ((m-1) & sal.line)))/3.32192809); 698 699 /* If we don't already know the full absolute file name of the 700 source file, find it now. */ 701 if (!sal.symtab->fullname) 702 { 703 fn = symtab_to_fullname (sal.symtab); 704 if (!fn) 705 fn = "unknown"; 706 } 707 else 708 fn = sal.symtab->fullname; 709 710 /* Quote the file name, in case it has whitespace or other special 711 characters. */ 712 p = xstrprintf ("%s +%d \"%s\"", editor, sal.line, fn); 713 shell_escape(p, from_tty); 714 xfree(p); 715} 716 717static void 718list_command (char *arg, int from_tty) 719{ 720 struct symtabs_and_lines sals, sals_end; 721 struct symtab_and_line sal = { 0 }; 722 struct symtab_and_line sal_end = { 0 }; 723 struct symtab_and_line cursal = { 0 }; 724 struct symbol *sym; 725 char *arg1; 726 int no_end = 1; 727 int dummy_end = 0; 728 int dummy_beg = 0; 729 int linenum_beg = 0; 730 char *p; 731 732 /* Pull in the current default source line if necessary */ 733 if (arg == 0 || arg[0] == '+' || arg[0] == '-') 734 { 735 set_default_source_symtab_and_line (); 736 cursal = get_current_source_symtab_and_line (); 737 } 738 739 /* "l" or "l +" lists next ten lines. */ 740 741 if (arg == 0 || strcmp (arg, "+") == 0) 742 { 743 print_source_lines (cursal.symtab, cursal.line, 744 cursal.line + get_lines_to_list (), 0); 745 return; 746 } 747 748 /* "l -" lists previous ten lines, the ones before the ten just listed. */ 749 if (strcmp (arg, "-") == 0) 750 { 751 print_source_lines (cursal.symtab, 752 max (get_first_line_listed () - get_lines_to_list (), 1), 753 get_first_line_listed (), 0); 754 return; 755 } 756 757 /* Now if there is only one argument, decode it in SAL 758 and set NO_END. 759 If there are two arguments, decode them in SAL and SAL_END 760 and clear NO_END; however, if one of the arguments is blank, 761 set DUMMY_BEG or DUMMY_END to record that fact. */ 762 763 if (!have_full_symbols () && !have_partial_symbols ()) 764 error (_("No symbol table is loaded. Use the \"file\" command.")); 765 766 arg1 = arg; 767 if (*arg1 == ',') 768 dummy_beg = 1; 769 else 770 { 771 sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0); 772 773 if (!sals.nelts) 774 return; /* C++ */ 775 if (sals.nelts > 1) 776 { 777 ambiguous_line_spec (&sals); 778 xfree (sals.sals); 779 return; 780 } 781 782 sal = sals.sals[0]; 783 xfree (sals.sals); 784 } 785 786 /* Record whether the BEG arg is all digits. */ 787 788 for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++); 789 linenum_beg = (p == arg1); 790 791 while (*arg1 == ' ' || *arg1 == '\t') 792 arg1++; 793 if (*arg1 == ',') 794 { 795 no_end = 0; 796 arg1++; 797 while (*arg1 == ' ' || *arg1 == '\t') 798 arg1++; 799 if (*arg1 == 0) 800 dummy_end = 1; 801 else 802 { 803 if (dummy_beg) 804 sals_end = decode_line_1 (&arg1, 0, 0, 0, 0, 0); 805 else 806 sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0, 0); 807 if (sals_end.nelts == 0) 808 return; 809 if (sals_end.nelts > 1) 810 { 811 ambiguous_line_spec (&sals_end); 812 xfree (sals_end.sals); 813 return; 814 } 815 sal_end = sals_end.sals[0]; 816 xfree (sals_end.sals); 817 } 818 } 819 820 if (*arg1) 821 error (_("Junk at end of line specification.")); 822 823 if (!no_end && !dummy_beg && !dummy_end 824 && sal.symtab != sal_end.symtab) 825 error (_("Specified start and end are in different files.")); 826 if (dummy_beg && dummy_end) 827 error (_("Two empty args do not say what lines to list.")); 828 829 /* if line was specified by address, 830 first print exactly which line, and which file. 831 In this case, sal.symtab == 0 means address is outside 832 of all known source files, not that user failed to give a filename. */ 833 if (*arg == '*') 834 { 835 if (sal.symtab == 0) 836 /* FIXME-32x64--assumes sal.pc fits in long. */ 837 error (_("No source file for address %s."), 838 hex_string ((unsigned long) sal.pc)); 839 sym = find_pc_function (sal.pc); 840 if (sym) 841 { 842 deprecated_print_address_numeric (sal.pc, 1, gdb_stdout); 843 printf_filtered (" is in "); 844 fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout); 845 printf_filtered (" (%s:%d).\n", sal.symtab->filename, sal.line); 846 } 847 else 848 { 849 deprecated_print_address_numeric (sal.pc, 1, gdb_stdout); 850 printf_filtered (" is at %s:%d.\n", 851 sal.symtab->filename, sal.line); 852 } 853 } 854 855 /* If line was not specified by just a line number, 856 and it does not imply a symtab, it must be an undebuggable symbol 857 which means no source code. */ 858 859 if (!linenum_beg && sal.symtab == 0) 860 error (_("No line number known for %s."), arg); 861 862 /* If this command is repeated with RET, 863 turn it into the no-arg variant. */ 864 865 if (from_tty) 866 *arg = 0; 867 868 if (dummy_beg && sal_end.symtab == 0) 869 error (_("No default source file yet. Do \"help list\".")); 870 if (dummy_beg) 871 print_source_lines (sal_end.symtab, 872 max (sal_end.line - (get_lines_to_list () - 1), 1), 873 sal_end.line + 1, 0); 874 else if (sal.symtab == 0) 875 error (_("No default source file yet. Do \"help list\".")); 876 else if (no_end) 877 { 878 int first_line = sal.line - get_lines_to_list () / 2; 879 880 if (first_line < 1) first_line = 1; 881 882 print_source_lines (sal.symtab, 883 first_line, 884 first_line + get_lines_to_list (), 885 0); 886 } 887 else 888 print_source_lines (sal.symtab, sal.line, 889 (dummy_end 890 ? sal.line + get_lines_to_list () 891 : sal_end.line + 1), 892 0); 893} 894 895/* Dump a specified section of assembly code. With no command line 896 arguments, this command will dump the assembly code for the 897 function surrounding the pc value in the selected frame. With one 898 argument, it will dump the assembly code surrounding that pc value. 899 Two arguments are interpeted as bounds within which to dump 900 assembly. */ 901 902static void 903disassemble_command (char *arg, int from_tty) 904{ 905 CORE_ADDR low, high; 906 char *name; 907 CORE_ADDR pc, pc_masked; 908 char *space_index; 909#if 0 910 asection *section; 911#endif 912 913 name = NULL; 914 if (!arg) 915 { 916 pc = get_frame_pc (get_selected_frame (_("No frame selected."))); 917 if (find_pc_partial_function (pc, &name, &low, &high) == 0) 918 error (_("No function contains program counter for selected frame.")); 919#if defined(TUI) 920 /* NOTE: cagney/2003-02-13 The `tui_active' was previously 921 `tui_version'. */ 922 if (tui_active) 923 /* FIXME: cagney/2004-02-07: This should be an observer. */ 924 low = tui_get_low_disassembly_address (low, pc); 925#endif 926 low += gdbarch_deprecated_function_start_offset (current_gdbarch); 927 } 928 else if (!(space_index = (char *) strchr (arg, ' '))) 929 { 930 /* One argument. */ 931 pc = parse_and_eval_address (arg); 932 if (find_pc_partial_function (pc, &name, &low, &high) == 0) 933 error (_("No function contains specified address.")); 934#if defined(TUI) 935 /* NOTE: cagney/2003-02-13 The `tui_active' was previously 936 `tui_version'. */ 937 if (tui_active) 938 /* FIXME: cagney/2004-02-07: This should be an observer. */ 939 low = tui_get_low_disassembly_address (low, pc); 940#endif 941 low += gdbarch_deprecated_function_start_offset (current_gdbarch); 942 } 943 else 944 { 945 /* Two arguments. */ 946 *space_index = '\0'; 947 low = parse_and_eval_address (arg); 948 high = parse_and_eval_address (space_index + 1); 949 } 950 951#if defined(TUI) 952 if (!tui_is_window_visible (DISASSEM_WIN)) 953#endif 954 { 955 printf_filtered ("Dump of assembler code "); 956 if (name != NULL) 957 { 958 printf_filtered ("for function %s:\n", name); 959 } 960 else 961 { 962 printf_filtered ("from "); 963 deprecated_print_address_numeric (low, 1, gdb_stdout); 964 printf_filtered (" to "); 965 deprecated_print_address_numeric (high, 1, gdb_stdout); 966 printf_filtered (":\n"); 967 } 968 969 /* Dump the specified range. */ 970 gdb_disassembly (uiout, 0, 0, 0, -1, low, high); 971 972 printf_filtered ("End of assembler dump.\n"); 973 gdb_flush (gdb_stdout); 974 } 975#if defined(TUI) 976 else 977 { 978 tui_show_assembly (low); 979 } 980#endif 981} 982 983static void 984make_command (char *arg, int from_tty) 985{ 986 char *p; 987 988 if (arg == 0) 989 p = "make"; 990 else 991 { 992 p = xmalloc (sizeof ("make ") + strlen (arg)); 993 strcpy (p, "make "); 994 strcpy (p + sizeof ("make ") - 1, arg); 995 } 996 997 shell_escape (p, from_tty); 998} 999 1000static void 1001show_user (char *args, int from_tty) 1002{ 1003 struct cmd_list_element *c; 1004 extern struct cmd_list_element *cmdlist; 1005 1006 if (args) 1007 { 1008 c = lookup_cmd (&args, cmdlist, "", 0, 1); 1009 if (c->class != class_user) 1010 error (_("Not a user command.")); 1011 show_user_1 (c, gdb_stdout); 1012 } 1013 else 1014 { 1015 for (c = cmdlist; c; c = c->next) 1016 { 1017 if (c->class == class_user) 1018 show_user_1 (c, gdb_stdout); 1019 } 1020 } 1021} 1022 1023/* Search through names of commands and documentations for a certain 1024 regular expression. 1025*/ 1026void 1027apropos_command (char *searchstr, int from_tty) 1028{ 1029 extern struct cmd_list_element *cmdlist; /*This is the main command list*/ 1030 regex_t pattern; 1031 char *pattern_fastmap; 1032 char errorbuffer[512]; 1033 pattern_fastmap = xcalloc (256, sizeof (char)); 1034 if (searchstr == NULL) 1035 error (_("REGEXP string is empty")); 1036 1037 if (regcomp(&pattern,searchstr,REG_ICASE) == 0) 1038 { 1039 pattern.fastmap=pattern_fastmap; 1040 re_compile_fastmap(&pattern); 1041 apropos_cmd (gdb_stdout,cmdlist,&pattern,""); 1042 } 1043 else 1044 { 1045 regerror(regcomp(&pattern,searchstr,REG_ICASE),NULL,errorbuffer,512); 1046 error (_("Error in regular expression:%s"),errorbuffer); 1047 } 1048 xfree (pattern_fastmap); 1049} 1050 1051/* Print a list of files and line numbers which a user may choose from 1052 in order to list a function which was specified ambiguously (as with 1053 `list classname::overloadedfuncname', for example). The vector in 1054 SALS provides the filenames and line numbers. */ 1055 1056static void 1057ambiguous_line_spec (struct symtabs_and_lines *sals) 1058{ 1059 int i; 1060 1061 for (i = 0; i < sals->nelts; ++i) 1062 printf_filtered (_("file: \"%s\", line number: %d\n"), 1063 sals->sals[i].symtab->filename, sals->sals[i].line); 1064} 1065 1066static void 1067set_debug (char *arg, int from_tty) 1068{ 1069 printf_unfiltered (_("\"set debug\" must be followed by the name of a print subcommand.\n")); 1070 help_list (setdebuglist, "set debug ", -1, gdb_stdout); 1071} 1072 1073static void 1074show_debug (char *args, int from_tty) 1075{ 1076 cmd_show_list (showdebuglist, from_tty, ""); 1077} 1078 1079void 1080init_cmd_lists (void) 1081{ 1082 max_user_call_depth = 1024; 1083 1084 cmdlist = NULL; 1085 infolist = NULL; 1086 enablelist = NULL; 1087 disablelist = NULL; 1088 togglelist = NULL; 1089 stoplist = NULL; 1090 deletelist = NULL; 1091 detachlist = NULL; 1092 enablebreaklist = NULL; 1093 setlist = NULL; 1094 unsetlist = NULL; 1095 showlist = NULL; 1096 sethistlist = NULL; 1097 showhistlist = NULL; 1098 unsethistlist = NULL; 1099 maintenancelist = NULL; 1100 maintenanceinfolist = NULL; 1101 maintenanceprintlist = NULL; 1102 setprintlist = NULL; 1103 showprintlist = NULL; 1104 setchecklist = NULL; 1105 showchecklist = NULL; 1106} 1107 1108static void 1109show_info_verbose (struct ui_file *file, int from_tty, 1110 struct cmd_list_element *c, 1111 const char *value) 1112{ 1113 if (info_verbose) 1114 fprintf_filtered (file, _("\ 1115Verbose printing of informational messages is %s.\n"), value); 1116 else 1117 fprintf_filtered (file, _("Verbosity is %s.\n"), value); 1118} 1119 1120static void 1121show_history_expansion_p (struct ui_file *file, int from_tty, 1122 struct cmd_list_element *c, const char *value) 1123{ 1124 fprintf_filtered (file, _("History expansion on command input is %s.\n"), 1125 value); 1126} 1127 1128static void 1129show_baud_rate (struct ui_file *file, int from_tty, 1130 struct cmd_list_element *c, const char *value) 1131{ 1132 fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"), 1133 value); 1134} 1135 1136static void 1137show_remote_debug (struct ui_file *file, int from_tty, 1138 struct cmd_list_element *c, const char *value) 1139{ 1140 fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"), 1141 value); 1142} 1143 1144static void 1145show_remote_timeout (struct ui_file *file, int from_tty, 1146 struct cmd_list_element *c, const char *value) 1147{ 1148 fprintf_filtered (file, _("\ 1149Timeout limit to wait for target to respond is %s.\n"), 1150 value); 1151} 1152 1153static void 1154show_max_user_call_depth (struct ui_file *file, int from_tty, 1155 struct cmd_list_element *c, const char *value) 1156{ 1157 fprintf_filtered (file, _("\ 1158The max call depth for user-defined commands is %s.\n"), 1159 value); 1160} 1161 1162 1163void 1164init_cli_cmds (void) 1165{ 1166 struct cmd_list_element *c; 1167 char *source_help_text; 1168 1169 /* Define the classes of commands. 1170 They will appear in the help list in the reverse of this order. */ 1171 1172 add_cmd ("internals", class_maintenance, NULL, _("\ 1173Maintenance commands.\n\ 1174Some gdb commands are provided just for use by gdb maintainers.\n\ 1175These commands are subject to frequent change, and may not be as\n\ 1176well documented as user commands."), 1177 &cmdlist); 1178 add_cmd ("obscure", class_obscure, NULL, _("Obscure features."), &cmdlist); 1179 add_cmd ("aliases", class_alias, NULL, _("Aliases of other commands."), &cmdlist); 1180 add_cmd ("user-defined", class_user, NULL, _("\ 1181User-defined commands.\n\ 1182The commands in this class are those defined by the user.\n\ 1183Use the \"define\" command to define a command."), &cmdlist); 1184 add_cmd ("support", class_support, NULL, _("Support facilities."), &cmdlist); 1185 if (!dbx_commands) 1186 add_cmd ("status", class_info, NULL, _("Status inquiries."), &cmdlist); 1187 add_cmd ("files", class_files, NULL, _("Specifying and examining files."), 1188 &cmdlist); 1189 add_cmd ("breakpoints", class_breakpoint, NULL, 1190 _("Making program stop at certain points."), &cmdlist); 1191 add_cmd ("data", class_vars, NULL, _("Examining data."), &cmdlist); 1192 add_cmd ("stack", class_stack, NULL, _("\ 1193Examining the stack.\n\ 1194The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\ 1195counting from zero for the innermost (currently executing) frame.\n\n\ 1196At any time gdb identifies one frame as the \"selected\" frame.\n\ 1197Variable lookups are done with respect to the selected frame.\n\ 1198When the program being debugged stops, gdb selects the innermost frame.\n\ 1199The commands below can be used to select other frames by number or address."), 1200 &cmdlist); 1201 add_cmd ("running", class_run, NULL, _("Running the program."), &cmdlist); 1202 1203 /* Define general commands. */ 1204 1205 add_com ("pwd", class_files, pwd_command, _("\ 1206Print working directory. This is used for your program as well.")); 1207 c = add_cmd ("cd", class_files, cd_command, _("\ 1208Set working directory to DIR for debugger and program being debugged.\n\ 1209The change does not take effect for the program being debugged\n\ 1210until the next time it is started."), &cmdlist); 1211 set_cmd_completer (c, filename_completer); 1212 1213 add_com ("echo", class_support, echo_command, _("\ 1214Print a constant string. Give string as argument.\n\ 1215C escape sequences may be used in the argument.\n\ 1216No newline is added at the end of the argument;\n\ 1217use \"\\n\" if you want a newline to be printed.\n\ 1218Since leading and trailing whitespace are ignored in command arguments,\n\ 1219if you want to print some you must use \"\\\" before leading whitespace\n\ 1220to be printed or after trailing whitespace.")); 1221 add_com ("document", class_support, document_command, _("\ 1222Document a user-defined command.\n\ 1223Give command name as argument. Give documentation on following lines.\n\ 1224End with a line of just \"end\".")); 1225 add_com ("define", class_support, define_command, _("\ 1226Define a new command name. Command name is argument.\n\ 1227Definition appears on following lines, one command per line.\n\ 1228End with a line of just \"end\".\n\ 1229Use the \"document\" command to give documentation for the new command.\n\ 1230Commands defined in this way may have up to ten arguments.")); 1231 1232 source_help_text = xstrprintf (_("\ 1233Read commands from a file named FILE.\n\ 1234Optional -v switch (before the filename) causes each command in\n\ 1235FILE to be echoed as it is executed.\n\ 1236Note that the file \"%s\" is read automatically in this way\n\ 1237when GDB is started."), gdbinit); 1238 c = add_cmd ("source", class_support, source_command, 1239 source_help_text, &cmdlist); 1240 set_cmd_completer (c, filename_completer); 1241 1242 add_com ("quit", class_support, quit_command, _("Exit gdb.")); 1243 c = add_com ("help", class_support, help_command, 1244 _("Print list of commands.")); 1245 set_cmd_completer (c, command_completer); 1246 add_com_alias ("q", "quit", class_support, 1); 1247 add_com_alias ("h", "help", class_support, 1); 1248 1249 add_setshow_boolean_cmd ("verbose", class_support, &info_verbose, _("\ 1250Set verbosity."), _("\ 1251Show verbosity."), NULL, 1252 set_verbose, 1253 show_info_verbose, 1254 &setlist, &showlist); 1255 1256 add_prefix_cmd ("history", class_support, set_history, 1257 _("Generic command for setting command history parameters."), 1258 &sethistlist, "set history ", 0, &setlist); 1259 add_prefix_cmd ("history", class_support, show_history, 1260 _("Generic command for showing command history parameters."), 1261 &showhistlist, "show history ", 0, &showlist); 1262 1263 add_setshow_boolean_cmd ("expansion", no_class, &history_expansion_p, _("\ 1264Set history expansion on command input."), _("\ 1265Show history expansion on command input."), _("\ 1266Without an argument, history expansion is enabled."), 1267 NULL, 1268 show_history_expansion_p, 1269 &sethistlist, &showhistlist); 1270 1271 add_prefix_cmd ("info", class_info, info_command, _("\ 1272Generic command for showing things about the program being debugged."), 1273 &infolist, "info ", 0, &cmdlist); 1274 add_com_alias ("i", "info", class_info, 1); 1275 1276 add_com ("complete", class_obscure, complete_command, 1277 _("List the completions for the rest of the line as a command.")); 1278 1279 add_prefix_cmd ("show", class_info, show_command, 1280 _("Generic command for showing things about the debugger."), 1281 &showlist, "show ", 0, &cmdlist); 1282 /* Another way to get at the same thing. */ 1283 add_info ("set", show_command, _("Show all GDB settings.")); 1284 1285 add_cmd ("commands", no_class, show_commands, _("\ 1286Show the history of commands you typed.\n\ 1287You can supply a command number to start with, or a `+' to start after\n\ 1288the previous command number shown."), 1289 &showlist); 1290 1291 add_cmd ("version", no_class, show_version, 1292 _("Show what version of GDB this is."), &showlist); 1293 1294 add_com ("while", class_support, while_command, _("\ 1295Execute nested commands WHILE the conditional expression is non zero.\n\ 1296The conditional expression must follow the word `while' and must in turn be\n\ 1297followed by a new line. The nested commands must be entered one per line,\n\ 1298and should be terminated by the word `end'.")); 1299 1300 add_com ("if", class_support, if_command, _("\ 1301Execute nested commands once IF the conditional expression is non zero.\n\ 1302The conditional expression must follow the word `if' and must in turn be\n\ 1303followed by a new line. The nested commands must be entered one per line,\n\ 1304and should be terminated by the word 'else' or `end'. If an else clause\n\ 1305is used, the same rules apply to its nested commands as to the first ones.")); 1306 1307 /* If target is open when baud changes, it doesn't take effect until the 1308 next open (I think, not sure). */ 1309 add_setshow_zinteger_cmd ("remotebaud", no_class, &baud_rate, _("\ 1310Set baud rate for remote serial I/O."), _("\ 1311Show baud rate for remote serial I/O."), _("\ 1312This value is used to set the speed of the serial port when debugging\n\ 1313using remote targets."), 1314 NULL, 1315 show_baud_rate, 1316 &setlist, &showlist); 1317 1318 add_setshow_zinteger_cmd ("remote", no_class, &remote_debug, _("\ 1319Set debugging of remote protocol."), _("\ 1320Show debugging of remote protocol."), _("\ 1321When enabled, each packet sent or received with the remote target\n\ 1322is displayed."), 1323 NULL, 1324 show_remote_debug, 1325 &setdebuglist, &showdebuglist); 1326 1327 add_setshow_integer_cmd ("remotetimeout", no_class, &remote_timeout, _("\ 1328Set timeout limit to wait for target to respond."), _("\ 1329Show timeout limit to wait for target to respond."), _("\ 1330This value is used to set the time limit for gdb to wait for a response\n\ 1331from the target."), 1332 NULL, 1333 show_remote_timeout, 1334 &setlist, &showlist); 1335 1336 add_prefix_cmd ("debug", no_class, set_debug, 1337 _("Generic command for setting gdb debugging flags"), 1338 &setdebuglist, "set debug ", 0, &setlist); 1339 1340 add_prefix_cmd ("debug", no_class, show_debug, 1341 _("Generic command for showing gdb debugging flags"), 1342 &showdebuglist, "show debug ", 0, &showlist); 1343 1344 c = add_com ("shell", class_support, shell_escape, _("\ 1345Execute the rest of the line as a shell command.\n\ 1346With no arguments, run an inferior shell.")); 1347 set_cmd_completer (c, filename_completer); 1348 1349 c = add_com ("edit", class_files, edit_command, _("\ 1350Edit specified file or function.\n\ 1351With no argument, edits file containing most recent line listed.\n\ 1352Editing targets can be specified in these ways:\n\ 1353 FILE:LINENUM, to edit at that line in that file,\n\ 1354 FUNCTION, to edit at the beginning of that function,\n\ 1355 FILE:FUNCTION, to distinguish among like-named static functions.\n\ 1356 *ADDRESS, to edit at the line containing that address.\n\ 1357Uses EDITOR environment variable contents as editor (or ex as default).")); 1358 1359 c->completer = location_completer; 1360 1361 add_com ("list", class_files, list_command, _("\ 1362List specified function or line.\n\ 1363With no argument, lists ten more lines after or around previous listing.\n\ 1364\"list -\" lists the ten lines before a previous ten-line listing.\n\ 1365One argument specifies a line, and ten lines are listed around that line.\n\ 1366Two arguments with comma between specify starting and ending lines to list.\n\ 1367Lines can be specified in these ways:\n\ 1368 LINENUM, to list around that line in current file,\n\ 1369 FILE:LINENUM, to list around that line in that file,\n\ 1370 FUNCTION, to list around beginning of that function,\n\ 1371 FILE:FUNCTION, to distinguish among like-named static functions.\n\ 1372 *ADDRESS, to list around the line containing that address.\n\ 1373With two args if one is empty it stands for ten lines away from the other arg.")); 1374 1375 if (!xdb_commands) 1376 add_com_alias ("l", "list", class_files, 1); 1377 else 1378 add_com_alias ("v", "list", class_files, 1); 1379 1380 if (dbx_commands) 1381 add_com_alias ("file", "list", class_files, 1); 1382 1383 c = add_com ("disassemble", class_vars, disassemble_command, _("\ 1384Disassemble a specified section of memory.\n\ 1385Default is the function surrounding the pc of the selected frame.\n\ 1386With a single argument, the function surrounding that address is dumped.\n\ 1387Two arguments are taken as a range of memory to dump.")); 1388 set_cmd_completer (c, location_completer); 1389 if (xdb_commands) 1390 add_com_alias ("va", "disassemble", class_xdb, 0); 1391 1392 /* NOTE: cagney/2000-03-20: Being able to enter ``(gdb) !ls'' would 1393 be a really useful feature. Unfortunately, the below wont do 1394 this. Instead it adds support for the form ``(gdb) ! ls'' 1395 (i.e. the space is required). If the ``!'' command below is 1396 added the complains about no ``!'' command would be replaced by 1397 complains about how the ``!'' command is broken :-) */ 1398 if (xdb_commands) 1399 add_com_alias ("!", "shell", class_support, 0); 1400 1401 c = add_com ("make", class_support, make_command, _("\ 1402Run the ``make'' program using the rest of the line as arguments.")); 1403 set_cmd_completer (c, filename_completer); 1404 add_cmd ("user", no_class, show_user, _("\ 1405Show definitions of user defined commands.\n\ 1406Argument is the name of the user defined command.\n\ 1407With no argument, show definitions of all user defined commands."), &showlist); 1408 add_com ("apropos", class_support, apropos_command, 1409 _("Search for commands matching a REGEXP")); 1410 1411 add_setshow_integer_cmd ("max-user-call-depth", no_class, 1412 &max_user_call_depth, _("\ 1413Set the max call depth for user-defined commands."), _("\ 1414Show the max call depth for user-defined commands."), NULL, 1415 NULL, 1416 show_max_user_call_depth, 1417 &setlist, &showlist); 1418 1419 add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\ 1420Set tracing of GDB CLI commands."), _("\ 1421Show state of GDB CLI command tracing."), _("\ 1422When 'on', each command is displayed as it is executed."), 1423 NULL, 1424 NULL, 1425 &setlist, &showlist); 1426} 1427