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