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