1 /* Top level stuff for GDB, the GNU debugger. 2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21 #include "defs.h" 22 #include "gdbcmd.h" 23 #include "call-cmds.h" 24 #include "symtab.h" 25 #include "inferior.h" 26 #include "signals.h" 27 #include "target.h" 28 #include "breakpoint.h" 29 #include "gdbtypes.h" 30 #include "expression.h" 31 #include "value.h" 32 #include "language.h" 33 #include "terminal.h" /* For job_control. */ 34 #include "annotate.h" 35 #include <setjmp.h> 36 #include "top.h" 37 38 /* readline include files */ 39 #include "readline.h" 40 #include "history.h" 41 42 /* readline defines this. */ 43 #undef savestring 44 45 #include <sys/types.h> 46 #ifdef HAVE_UNISTD_H 47 #include <unistd.h> 48 #endif 49 50 #include "gdb_string.h" 51 #include "gdb_stat.h" 52 #include <ctype.h> 53 54 extern void initialize_utils PARAMS ((void)); 55 56 /* Prototypes for local functions */ 57 58 static void dont_repeat_command PARAMS ((char *, int)); 59 60 static void source_cleanup_lines PARAMS ((PTR)); 61 62 static void user_defined_command PARAMS ((char *, int)); 63 64 static void init_signals PARAMS ((void)); 65 66 #ifdef STOP_SIGNAL 67 static void stop_sig PARAMS ((int)); 68 #endif 69 70 static void disconnect PARAMS ((int)); 71 72 static char * line_completion_function PARAMS ((char *, int, char *, int)); 73 74 static char * readline_line_completion_function PARAMS ((char *, int)); 75 76 static void command_loop_marker PARAMS ((int)); 77 78 static void while_command PARAMS ((char *, int)); 79 80 static void if_command PARAMS ((char *, int)); 81 82 static struct command_line * 83 build_command_line PARAMS ((enum command_control_type, char *)); 84 85 static struct command_line * 86 get_command_line PARAMS ((enum command_control_type, char *)); 87 88 static void realloc_body_list PARAMS ((struct command_line *, int)); 89 90 static enum misc_command_type read_next_line PARAMS ((struct command_line **)); 91 92 static enum command_control_type 93 recurse_read_control_structure PARAMS ((struct command_line *)); 94 95 static struct cleanup * setup_user_args PARAMS ((char *)); 96 97 static char * locate_arg PARAMS ((char *)); 98 99 static char * insert_args PARAMS ((char *)); 100 101 static void arg_cleanup PARAMS ((void)); 102 103 static void init_main PARAMS ((void)); 104 105 static void init_cmd_lists PARAMS ((void)); 106 107 static void float_handler PARAMS ((int)); 108 109 static void init_signals PARAMS ((void)); 110 111 static void set_verbose PARAMS ((char *, int, struct cmd_list_element *)); 112 113 #ifdef TARGET_BYTE_ORDER_SELECTABLE 114 115 static void set_endian PARAMS ((char *, int)); 116 117 static void set_endian_big PARAMS ((char *, int)); 118 119 static void set_endian_little PARAMS ((char *, int)); 120 121 static void set_endian_auto PARAMS ((char *, int)); 122 123 static void show_endian PARAMS ((char *, int)); 124 125 #endif 126 127 static void show_history PARAMS ((char *, int)); 128 129 static void set_history PARAMS ((char *, int)); 130 131 static void set_history_size_command PARAMS ((char *, int, 132 struct cmd_list_element *)); 133 134 static void show_commands PARAMS ((char *, int)); 135 136 static void echo_command PARAMS ((char *, int)); 137 138 static void pwd_command PARAMS ((char *, int)); 139 140 static void show_version PARAMS ((char *, int)); 141 142 static void document_command PARAMS ((char *, int)); 143 144 static void define_command PARAMS ((char *, int)); 145 146 static void validate_comname PARAMS ((char *)); 147 148 static void help_command PARAMS ((char *, int)); 149 150 static void show_command PARAMS ((char *, int)); 151 152 static void info_command PARAMS ((char *, int)); 153 154 static void complete_command PARAMS ((char *, int)); 155 156 static void do_nothing PARAMS ((int)); 157 158 static int quit_cover PARAMS ((char *)); 159 160 static void disconnect PARAMS ((int)); 161 162 static void source_cleanup PARAMS ((FILE *)); 163 164 /* If this definition isn't overridden by the header files, assume 165 that isatty and fileno exist on this system. */ 166 #ifndef ISATTY 167 #define ISATTY(FP) (isatty (fileno (FP))) 168 #endif 169 170 /* Initialization file name for gdb. This is overridden in some configs. */ 171 172 #ifndef GDBINIT_FILENAME 173 #define GDBINIT_FILENAME ".gdbinit" 174 #endif 175 char gdbinit[] = GDBINIT_FILENAME; 176 177 int inhibit_gdbinit = 0; 178 179 /* If nonzero, and GDB has been configured to be able to use windows, 180 attempt to open them upon startup. */ 181 182 int use_windows = 1; 183 184 /* Version number of GDB, as a string. */ 185 186 extern char *version; 187 188 /* Canonical host name as a string. */ 189 190 extern char *host_name; 191 192 /* Canonical target name as a string. */ 193 194 extern char *target_name; 195 196 extern char lang_frame_mismatch_warn[]; /* language.c */ 197 198 /* Flag for whether we want all the "from_tty" gubbish printed. */ 199 200 int caution = 1; /* Default is yes, sigh. */ 201 202 /* Define all cmd_list_elements. */ 203 204 /* Chain containing all defined commands. */ 205 206 struct cmd_list_element *cmdlist; 207 208 /* Chain containing all defined info subcommands. */ 209 210 struct cmd_list_element *infolist; 211 212 /* Chain containing all defined enable subcommands. */ 213 214 struct cmd_list_element *enablelist; 215 216 /* Chain containing all defined disable subcommands. */ 217 218 struct cmd_list_element *disablelist; 219 220 /* Chain containing all defined delete subcommands. */ 221 222 struct cmd_list_element *deletelist; 223 224 /* Chain containing all defined "enable breakpoint" subcommands. */ 225 226 struct cmd_list_element *enablebreaklist; 227 228 /* Chain containing all defined set subcommands */ 229 230 struct cmd_list_element *setlist; 231 232 /* Chain containing all defined unset subcommands */ 233 234 struct cmd_list_element *unsetlist; 235 236 /* Chain containing all defined show subcommands. */ 237 238 struct cmd_list_element *showlist; 239 240 #ifdef TARGET_BYTE_ORDER_SELECTABLE 241 /* Chain containing the \"set endian\" commands. */ 242 243 struct cmd_list_element *endianlist; 244 #endif 245 246 /* Chain containing all defined \"set history\". */ 247 248 struct cmd_list_element *sethistlist; 249 250 /* Chain containing all defined \"show history\". */ 251 252 struct cmd_list_element *showhistlist; 253 254 /* Chain containing all defined \"unset history\". */ 255 256 struct cmd_list_element *unsethistlist; 257 258 /* Chain containing all defined maintenance subcommands. */ 259 260 #if MAINTENANCE_CMDS 261 struct cmd_list_element *maintenancelist; 262 #endif 263 264 /* Chain containing all defined "maintenance info" subcommands. */ 265 266 #if MAINTENANCE_CMDS 267 struct cmd_list_element *maintenanceinfolist; 268 #endif 269 270 /* Chain containing all defined "maintenance print" subcommands. */ 271 272 #if MAINTENANCE_CMDS 273 struct cmd_list_element *maintenanceprintlist; 274 #endif 275 276 struct cmd_list_element *setprintlist; 277 278 struct cmd_list_element *showprintlist; 279 280 struct cmd_list_element *setchecklist; 281 282 struct cmd_list_element *showchecklist; 283 284 /* stdio stream that command input is being read from. Set to stdin normally. 285 Set by source_command to the file we are sourcing. Set to NULL if we are 286 executing a user-defined command or interacting via a GUI. */ 287 288 FILE *instream; 289 290 /* Current working directory. */ 291 292 char *current_directory; 293 294 /* The directory name is actually stored here (usually). */ 295 char gdb_dirbuf[1024]; 296 297 /* Function to call before reading a command, if nonzero. 298 The function receives two args: an input stream, 299 and a prompt string. */ 300 301 void (*window_hook) PARAMS ((FILE *, char *)); 302 303 int epoch_interface; 304 int xgdb_verbose; 305 306 /* gdb prints this when reading a command interactively */ 307 static char *prompt; 308 309 /* Buffer used for reading command lines, and the size 310 allocated for it so far. */ 311 312 char *line; 313 int linesize = 100; 314 315 /* Nonzero if the current command is modified by "server ". This 316 affects things like recording into the command history, comamnds 317 repeating on RETURN, etc. This is so a user interface (emacs, GUI, 318 whatever) can issue its own commands and also send along commands 319 from the user, and have the user not notice that the user interface 320 is issuing commands too. */ 321 int server_command; 322 323 /* Baud rate specified for talking to serial target systems. Default 324 is left as -1, so targets can choose their own defaults. */ 325 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1 326 or (unsigned int)-1. This is a Bad User Interface. */ 327 328 int baud_rate = -1; 329 330 /* Timeout limit for response from target. */ 331 332 int remote_timeout = 20; /* Set default to 20 */ 333 334 /* Non-zero tells remote* modules to output debugging info. */ 335 336 int remote_debug = 0; 337 338 /* Level of control structure. */ 339 static int control_level; 340 341 /* Structure for arguments to user defined functions. */ 342 #define MAXUSERARGS 10 343 struct user_args 344 { 345 struct user_args *next; 346 struct 347 { 348 char *arg; 349 int len; 350 } a[MAXUSERARGS]; 351 int count; 352 } *user_args; 353 354 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */ 355 356 #ifndef STOP_SIGNAL 357 #ifdef SIGTSTP 358 #define STOP_SIGNAL SIGTSTP 359 static void stop_sig PARAMS ((int)); 360 #endif 361 #endif 362 363 /* Some System V have job control but not sigsetmask(). */ 364 #if !defined (HAVE_SIGSETMASK) 365 #if !defined (USG) 366 #define HAVE_SIGSETMASK 1 367 #else 368 #define HAVE_SIGSETMASK 0 369 #endif 370 #endif 371 372 #if 0 == (HAVE_SIGSETMASK) 373 #define sigsetmask(n) 374 #endif 375 376 /* Hooks for alternate command interfaces. */ 377 378 /* Called after most modules have been initialized, but before taking users 379 command file. */ 380 381 void (*init_ui_hook) PARAMS ((void)); 382 383 /* Called instead of command_loop at top level. Can be invoked via 384 return_to_top_level. */ 385 386 void (*command_loop_hook) PARAMS ((void)); 387 388 389 /* Called instead of fputs for all output. */ 390 391 void (*fputs_unfiltered_hook) PARAMS ((const char *linebuffer, FILE *stream)); 392 393 /* Called when the target says something to the host, which may 394 want to appear in a different window. */ 395 396 void (*target_output_hook) PARAMS ((char *)); 397 398 /* Called from print_frame_info to list the line we stopped in. */ 399 400 void (*print_frame_info_listing_hook) PARAMS ((struct symtab *s, int line, 401 int stopline, int noerror)); 402 /* Replaces most of query. */ 403 404 int (*query_hook) PARAMS ((const char *, va_list)); 405 406 /* Called from gdb_flush to flush output. */ 407 408 void (*flush_hook) PARAMS ((FILE *stream)); 409 410 /* These three functions support getting lines of text from the user. They 411 are used in sequence. First readline_begin_hook is called with a text 412 string that might be (for example) a message for the user to type in a 413 sequence of commands to be executed at a breakpoint. If this function 414 calls back to a GUI, it might take this opportunity to pop up a text 415 interaction window with this message. Next, readline_hook is called 416 with a prompt that is emitted prior to collecting the user input. 417 It can be called multiple times. Finally, readline_end_hook is called 418 to notify the GUI that we are done with the interaction window and it 419 can close it. */ 420 421 void (*readline_begin_hook) PARAMS ((char *, ...)); 422 char * (*readline_hook) PARAMS ((char *)); 423 void (*readline_end_hook) PARAMS ((void)); 424 425 /* Called as appropriate to notify the interface of the specified breakpoint 426 conditions. */ 427 428 void (*create_breakpoint_hook) PARAMS ((struct breakpoint *bpt)); 429 void (*delete_breakpoint_hook) PARAMS ((struct breakpoint *bpt)); 430 void (*modify_breakpoint_hook) PARAMS ((struct breakpoint *bpt)); 431 432 /* Called during long calculations to allow GUI to repair window damage, and to 433 check for stop buttons, etc... */ 434 435 void (*interactive_hook) PARAMS ((void)); 436 437 /* Called when the registers have changed, as a hint to a GUI 438 to minimize window update. */ 439 440 void (*registers_changed_hook) PARAMS ((void)); 441 442 /* Called when going to wait for the target. Usually allows the GUI to run 443 while waiting for target events. */ 444 445 int (*target_wait_hook) PARAMS ((int pid, struct target_waitstatus *status)); 446 447 /* Used by UI as a wrapper around command execution. May do various things 448 like enabling/disabling buttons, etc... */ 449 450 void (*call_command_hook) PARAMS ((struct cmd_list_element *c, char *cmd, 451 int from_tty)); 452 453 454 /* Takes control from error (). Typically used to prevent longjmps out of the 455 middle of the GUI. Usually used in conjunction with a catch routine. */ 456 457 NORETURN void (*error_hook) PARAMS ((void)) ATTR_NORETURN; 458 459 460 /* Where to go for return_to_top_level (RETURN_ERROR). */ 461 jmp_buf error_return; 462 /* Where to go for return_to_top_level (RETURN_QUIT). */ 463 jmp_buf quit_return; 464 465 /* Return for reason REASON. This generally gets back to the command 466 loop, but can be caught via catch_errors. */ 467 468 NORETURN void 469 return_to_top_level (reason) 470 enum return_reason reason; 471 { 472 quit_flag = 0; 473 immediate_quit = 0; 474 475 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure 476 I can think of a reason why that is vital, though). */ 477 bpstat_clear_actions(stop_bpstat); /* Clear queued breakpoint commands */ 478 479 disable_current_display (); 480 do_cleanups (ALL_CLEANUPS); 481 482 if (annotation_level > 1) 483 switch (reason) 484 { 485 case RETURN_QUIT: 486 annotate_quit (); 487 break; 488 case RETURN_ERROR: 489 annotate_error (); 490 break; 491 } 492 493 (NORETURN void) longjmp 494 (reason == RETURN_ERROR ? error_return : quit_return, 1); 495 } 496 497 /* Call FUNC with arg ARGS, catching any errors. If there is no 498 error, return the value returned by FUNC. If there is an error, 499 print ERRSTRING, print the specific error message, then return 500 zero. 501 502 Must not be called with immediate_quit in effect (bad things might 503 happen, say we got a signal in the middle of a memcpy to quit_return). 504 This is an OK restriction; with very few exceptions immediate_quit can 505 be replaced by judicious use of QUIT. 506 507 MASK specifies what to catch; it is normally set to 508 RETURN_MASK_ALL, if for no other reason than that the code which 509 calls catch_errors might not be set up to deal with a quit which 510 isn't caught. But if the code can deal with it, it generally 511 should be RETURN_MASK_ERROR, unless for some reason it is more 512 useful to abort only the portion of the operation inside the 513 catch_errors. Note that quit should return to the command line 514 fairly quickly, even if some further processing is being done. */ 515 516 int 517 catch_errors (func, args, errstring, mask) 518 int (*func) PARAMS ((char *)); 519 PTR args; 520 char *errstring; 521 return_mask mask; 522 { 523 jmp_buf saved_error; 524 jmp_buf saved_quit; 525 jmp_buf tmp_jmp; 526 int val; 527 struct cleanup *saved_cleanup_chain; 528 char *saved_error_pre_print; 529 char *saved_quit_pre_print; 530 531 saved_cleanup_chain = save_cleanups (); 532 saved_error_pre_print = error_pre_print; 533 saved_quit_pre_print = quit_pre_print; 534 535 if (mask & RETURN_MASK_ERROR) 536 { 537 memcpy ((char *)saved_error, (char *)error_return, sizeof (jmp_buf)); 538 error_pre_print = errstring; 539 } 540 if (mask & RETURN_MASK_QUIT) 541 { 542 memcpy (saved_quit, quit_return, sizeof (jmp_buf)); 543 quit_pre_print = errstring; 544 } 545 546 if (setjmp (tmp_jmp) == 0) 547 { 548 if (mask & RETURN_MASK_ERROR) 549 memcpy (error_return, tmp_jmp, sizeof (jmp_buf)); 550 if (mask & RETURN_MASK_QUIT) 551 memcpy (quit_return, tmp_jmp, sizeof (jmp_buf)); 552 val = (*func) (args); 553 } 554 else 555 val = 0; 556 557 restore_cleanups (saved_cleanup_chain); 558 559 if (mask & RETURN_MASK_ERROR) 560 { 561 memcpy (error_return, saved_error, sizeof (jmp_buf)); 562 error_pre_print = saved_error_pre_print; 563 } 564 if (mask & RETURN_MASK_QUIT) 565 { 566 memcpy (quit_return, saved_quit, sizeof (jmp_buf)); 567 quit_pre_print = saved_quit_pre_print; 568 } 569 return val; 570 } 571 572 /* Handler for SIGHUP. */ 573 574 #ifndef _WIN32 575 static void 576 disconnect (signo) 577 int signo; 578 { 579 catch_errors (quit_cover, NULL, 580 "Could not kill the program being debugged", RETURN_MASK_ALL); 581 signal (SIGHUP, SIG_DFL); 582 kill (getpid (), SIGHUP); 583 } 584 #endif 585 586 /* Just a little helper function for disconnect(). */ 587 588 static int 589 quit_cover (s) 590 char *s; 591 { 592 caution = 0; /* Throw caution to the wind -- we're exiting. 593 This prevents asking the user dumb questions. */ 594 quit_command((char *)0, 0); 595 return 0; 596 } 597 598 /* Line number we are currently in in a file which is being sourced. */ 599 static int source_line_number; 600 601 /* Name of the file we are sourcing. */ 602 static char *source_file_name; 603 604 /* Buffer containing the error_pre_print used by the source stuff. 605 Malloc'd. */ 606 static char *source_error; 607 static int source_error_allocated; 608 609 /* Something to glom on to the start of error_pre_print if source_file_name 610 is set. */ 611 static char *source_pre_error; 612 613 /* Clean up on error during a "source" command (or execution of a 614 user-defined command). */ 615 616 static void 617 source_cleanup (stream) 618 FILE *stream; 619 { 620 /* Restore the previous input stream. */ 621 instream = stream; 622 } 623 624 /* Read commands from STREAM. */ 625 void 626 read_command_file (stream) 627 FILE *stream; 628 { 629 struct cleanup *cleanups; 630 631 cleanups = make_cleanup (source_cleanup, instream); 632 instream = stream; 633 command_loop (); 634 do_cleanups (cleanups); 635 } 636 637 extern void init_proc PARAMS ((void)); 638 639 void (*pre_init_ui_hook) PARAMS ((void)); 640 641 void 642 gdb_init () 643 { 644 if (pre_init_ui_hook) 645 pre_init_ui_hook (); 646 647 /* Run the init function of each source file */ 648 649 getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)); 650 current_directory = gdb_dirbuf; 651 652 init_cmd_lists (); /* This needs to be done first */ 653 initialize_targets (); /* Setup target_terminal macros for utils.c */ 654 initialize_utils (); /* Make errors and warnings possible */ 655 initialize_all_files (); 656 init_main (); /* But that omits this file! Do it now */ 657 init_signals (); 658 659 init_proc (); 660 661 /* We need a default language for parsing expressions, so simple things like 662 "set width 0" won't fail if no language is explicitly set in a config file 663 or implicitly set by reading an executable during startup. */ 664 set_language (language_c); 665 expected_language = current_language; /* don't warn about the change. */ 666 667 if (init_ui_hook) 668 init_ui_hook (); 669 } 670 671 /* Allocate, initialize a new command line structure for one of the 672 control commands (if/while). */ 673 674 static struct command_line * 675 build_command_line (type, args) 676 enum command_control_type type; 677 char *args; 678 { 679 struct command_line *cmd; 680 681 if (args == NULL) 682 error ("if/while commands require arguments.\n"); 683 684 cmd = (struct command_line *)xmalloc (sizeof (struct command_line)); 685 cmd->next = NULL; 686 cmd->control_type = type; 687 688 cmd->body_count = 1; 689 cmd->body_list 690 = (struct command_line **)xmalloc (sizeof (struct command_line *) 691 * cmd->body_count); 692 memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count); 693 cmd->line = savestring (args, strlen (args)); 694 return cmd; 695 } 696 697 /* Build and return a new command structure for the control commands 698 such as "if" and "while". */ 699 700 static struct command_line * 701 get_command_line (type, arg) 702 enum command_control_type type; 703 char *arg; 704 { 705 struct command_line *cmd; 706 struct cleanup *old_chain = NULL; 707 708 /* Allocate and build a new command line structure. */ 709 cmd = build_command_line (type, arg); 710 711 old_chain = make_cleanup (free_command_lines, &cmd); 712 713 /* Read in the body of this command. */ 714 if (recurse_read_control_structure (cmd) == invalid_control) 715 { 716 warning ("error reading in control structure\n"); 717 do_cleanups (old_chain); 718 return NULL; 719 } 720 721 discard_cleanups (old_chain); 722 return cmd; 723 } 724 725 /* Recursively print a command (including full control structures). */ 726 void 727 print_command_line (cmd, depth) 728 struct command_line *cmd; 729 unsigned int depth; 730 { 731 unsigned int i; 732 733 if (depth) 734 { 735 for (i = 0; i < depth; i++) 736 fputs_filtered (" ", gdb_stdout); 737 } 738 739 /* A simple command, print it and return. */ 740 if (cmd->control_type == simple_control) 741 { 742 fputs_filtered (cmd->line, gdb_stdout); 743 fputs_filtered ("\n", gdb_stdout); 744 return; 745 } 746 747 /* loop_continue to jump to the start of a while loop, print it 748 and return. */ 749 if (cmd->control_type == continue_control) 750 { 751 fputs_filtered ("loop_continue\n", gdb_stdout); 752 return; 753 } 754 755 /* loop_break to break out of a while loop, print it and return. */ 756 if (cmd->control_type == break_control) 757 { 758 fputs_filtered ("loop_break\n", gdb_stdout); 759 return; 760 } 761 762 /* A while command. Recursively print its subcommands before returning. */ 763 if (cmd->control_type == while_control) 764 { 765 struct command_line *list; 766 fputs_filtered ("while ", gdb_stdout); 767 fputs_filtered (cmd->line, gdb_stdout); 768 fputs_filtered ("\n", gdb_stdout); 769 list = *cmd->body_list; 770 while (list) 771 { 772 print_command_line (list, depth + 1); 773 list = list->next; 774 } 775 } 776 777 /* An if command. Recursively print both arms before returning. */ 778 if (cmd->control_type == if_control) 779 { 780 fputs_filtered ("if ", gdb_stdout); 781 fputs_filtered (cmd->line, gdb_stdout); 782 fputs_filtered ("\n", gdb_stdout); 783 /* The true arm. */ 784 print_command_line (cmd->body_list[0], depth + 1); 785 786 /* Show the false arm if it exists. */ 787 if (cmd->body_count == 2) 788 { 789 if (depth) 790 { 791 for (i = 0; i < depth; i++) 792 fputs_filtered (" ", gdb_stdout); 793 } 794 fputs_filtered ("else\n", gdb_stdout); 795 print_command_line (cmd->body_list[1], depth + 1); 796 } 797 if (depth) 798 { 799 for (i = 0; i < depth; i++) 800 fputs_filtered (" ", gdb_stdout); 801 } 802 fputs_filtered ("end\n", gdb_stdout); 803 } 804 } 805 806 /* Execute the command in CMD. */ 807 808 enum command_control_type 809 execute_control_command (cmd) 810 struct command_line *cmd; 811 { 812 struct expression *expr; 813 struct command_line *current; 814 struct cleanup *old_chain = 0; 815 value_ptr val; 816 value_ptr val_mark; 817 int loop; 818 enum command_control_type ret; 819 char *new_line; 820 821 switch (cmd->control_type) 822 { 823 case simple_control: 824 /* A simple command, execute it and return. */ 825 new_line = insert_args (cmd->line); 826 if (!new_line) 827 return invalid_control; 828 old_chain = make_cleanup (free_current_contents, &new_line); 829 execute_command (new_line, 0); 830 ret = cmd->control_type; 831 break; 832 833 case continue_control: 834 case break_control: 835 /* Return for "continue", and "break" so we can either 836 continue the loop at the top, or break out. */ 837 ret = cmd->control_type; 838 break; 839 840 case while_control: 841 { 842 /* Parse the loop control expression for the while statement. */ 843 new_line = insert_args (cmd->line); 844 if (!new_line) 845 return invalid_control; 846 old_chain = make_cleanup (free_current_contents, &new_line); 847 expr = parse_expression (new_line); 848 make_cleanup (free_current_contents, &expr); 849 850 ret = simple_control; 851 loop = 1; 852 853 /* Keep iterating so long as the expression is true. */ 854 while (loop == 1) 855 { 856 int cond_result; 857 858 QUIT; 859 860 /* Evaluate the expression. */ 861 val_mark = value_mark (); 862 val = evaluate_expression (expr); 863 cond_result = value_true (val); 864 value_free_to_mark (val_mark); 865 866 /* If the value is false, then break out of the loop. */ 867 if (!cond_result) 868 break; 869 870 /* Execute the body of the while statement. */ 871 current = *cmd->body_list; 872 while (current) 873 { 874 ret = execute_control_command (current); 875 876 /* If we got an error, or a "break" command, then stop 877 looping. */ 878 if (ret == invalid_control || ret == break_control) 879 { 880 loop = 0; 881 break; 882 } 883 884 /* If we got a "continue" command, then restart the loop 885 at this point. */ 886 if (ret == continue_control) 887 break; 888 889 /* Get the next statement. */ 890 current = current->next; 891 } 892 } 893 894 /* Reset RET so that we don't recurse the break all the way down. */ 895 if (ret == break_control) 896 ret = simple_control; 897 898 break; 899 } 900 901 case if_control: 902 { 903 new_line = insert_args (cmd->line); 904 if (!new_line) 905 return invalid_control; 906 old_chain = make_cleanup (free_current_contents, &new_line); 907 /* Parse the conditional for the if statement. */ 908 expr = parse_expression (new_line); 909 make_cleanup (free_current_contents, &expr); 910 911 current = NULL; 912 ret = simple_control; 913 914 /* Evaluate the conditional. */ 915 val_mark = value_mark (); 916 val = evaluate_expression (expr); 917 918 /* Choose which arm to take commands from based on the value of the 919 conditional expression. */ 920 if (value_true (val)) 921 current = *cmd->body_list; 922 else if (cmd->body_count == 2) 923 current = *(cmd->body_list + 1); 924 value_free_to_mark (val_mark); 925 926 /* Execute commands in the given arm. */ 927 while (current) 928 { 929 ret = execute_control_command (current); 930 931 /* If we got an error, get out. */ 932 if (ret != simple_control) 933 break; 934 935 /* Get the next statement in the body. */ 936 current = current->next; 937 } 938 939 break; 940 } 941 942 default: 943 warning ("Invalid control type in command structure."); 944 return invalid_control; 945 } 946 947 if (old_chain) 948 do_cleanups (old_chain); 949 950 return ret; 951 } 952 953 /* "while" command support. Executes a body of statements while the 954 loop condition is nonzero. */ 955 956 static void 957 while_command (arg, from_tty) 958 char *arg; 959 int from_tty; 960 { 961 struct command_line *command = NULL; 962 963 control_level = 1; 964 command = get_command_line (while_control, arg); 965 966 if (command == NULL) 967 return; 968 969 execute_control_command (command); 970 free_command_lines (&command); 971 } 972 973 /* "if" command support. Execute either the true or false arm depending 974 on the value of the if conditional. */ 975 976 static void 977 if_command (arg, from_tty) 978 char *arg; 979 int from_tty; 980 { 981 struct command_line *command = NULL; 982 983 control_level = 1; 984 command = get_command_line (if_control, arg); 985 986 if (command == NULL) 987 return; 988 989 execute_control_command (command); 990 free_command_lines (&command); 991 } 992 993 /* Cleanup */ 994 static void 995 arg_cleanup () 996 { 997 struct user_args *oargs = user_args; 998 if (!user_args) 999 fatal ("Internal error, arg_cleanup called with no user args.\n"); 1000 1001 user_args = user_args->next; 1002 free (oargs); 1003 } 1004 1005 /* Bind the incomming arguments for a user defined command to 1006 $arg0, $arg1 ... $argMAXUSERARGS. */ 1007 1008 static struct cleanup * 1009 setup_user_args (p) 1010 char *p; 1011 { 1012 struct user_args *args; 1013 struct cleanup *old_chain; 1014 unsigned int arg_count = 0; 1015 1016 args = (struct user_args *)xmalloc (sizeof (struct user_args)); 1017 memset (args, 0, sizeof (struct user_args)); 1018 1019 args->next = user_args; 1020 user_args = args; 1021 1022 old_chain = make_cleanup (arg_cleanup, 0); 1023 1024 if (p == NULL) 1025 return old_chain; 1026 1027 while (*p) 1028 { 1029 char *start_arg; 1030 1031 if (arg_count >= MAXUSERARGS) 1032 { 1033 error ("user defined function may only have %d arguments.\n", 1034 MAXUSERARGS); 1035 return old_chain; 1036 } 1037 1038 /* Strip whitespace. */ 1039 while (*p == ' ' || *p == '\t') 1040 p++; 1041 1042 /* P now points to an argument. */ 1043 start_arg = p; 1044 user_args->a[arg_count].arg = p; 1045 1046 /* Get to the end of this argument. */ 1047 while (*p && *p != ' ' && *p != '\t') 1048 p++; 1049 1050 user_args->a[arg_count].len = p - start_arg; 1051 arg_count++; 1052 user_args->count++; 1053 } 1054 return old_chain; 1055 } 1056 1057 /* Given character string P, return a point to the first argument ($arg), 1058 or NULL if P contains no arguments. */ 1059 1060 static char * 1061 locate_arg (p) 1062 char *p; 1063 { 1064 while ((p = strchr (p, '$'))) 1065 { 1066 if (strncmp (p, "$arg", 4) == 0 && isdigit (p[4])) 1067 return p; 1068 p++; 1069 } 1070 return NULL; 1071 } 1072 1073 /* Insert the user defined arguments stored in user_arg into the $arg 1074 arguments found in line, with the updated copy being placed into nline. */ 1075 1076 static char * 1077 insert_args (line) 1078 char *line; 1079 { 1080 char *p, *save_line, *new_line; 1081 unsigned len, i; 1082 1083 /* First we need to know how much memory to allocate for the new line. */ 1084 save_line = line; 1085 len = 0; 1086 while ((p = locate_arg (line))) 1087 { 1088 len += p - line; 1089 i = p[4] - '0'; 1090 1091 if (i >= user_args->count) 1092 { 1093 error ("Missing argument %d in user function.\n", i); 1094 return NULL; 1095 } 1096 len += user_args->a[i].len; 1097 line = p + 5; 1098 } 1099 1100 /* Don't forget the tail. */ 1101 len += strlen (line); 1102 1103 /* Allocate space for the new line and fill it in. */ 1104 new_line = (char *)xmalloc (len + 1); 1105 if (new_line == NULL) 1106 return NULL; 1107 1108 /* Restore pointer to beginning of old line. */ 1109 line = save_line; 1110 1111 /* Save pointer to beginning of new line. */ 1112 save_line = new_line; 1113 1114 while ((p = locate_arg (line))) 1115 { 1116 int i, len; 1117 1118 memcpy (new_line, line, p - line); 1119 new_line += p - line; 1120 i = p[4] - '0'; 1121 1122 len = user_args->a[i].len; 1123 if (len) 1124 { 1125 memcpy (new_line, user_args->a[i].arg, len); 1126 new_line += len; 1127 } 1128 line = p + 5; 1129 } 1130 /* Don't forget the tail. */ 1131 strcpy (new_line, line); 1132 1133 /* Return a pointer to the beginning of the new line. */ 1134 return save_line; 1135 } 1136 1137 void 1138 execute_user_command (c, args) 1139 struct cmd_list_element *c; 1140 char *args; 1141 { 1142 register struct command_line *cmdlines; 1143 struct cleanup *old_chain; 1144 enum command_control_type ret; 1145 1146 old_chain = setup_user_args (args); 1147 1148 cmdlines = c->user_commands; 1149 if (cmdlines == 0) 1150 /* Null command */ 1151 return; 1152 1153 /* Set the instream to 0, indicating execution of a 1154 user-defined function. */ 1155 old_chain = make_cleanup (source_cleanup, instream); 1156 instream = (FILE *) 0; 1157 while (cmdlines) 1158 { 1159 ret = execute_control_command (cmdlines); 1160 if (ret != simple_control && ret != break_control) 1161 { 1162 warning ("Error in control structure.\n"); 1163 break; 1164 } 1165 cmdlines = cmdlines->next; 1166 } 1167 do_cleanups (old_chain); 1168 } 1169 1170 /* Execute the line P as a command. 1171 Pass FROM_TTY as second argument to the defining function. */ 1172 1173 void 1174 execute_command (p, from_tty) 1175 char *p; 1176 int from_tty; 1177 { 1178 register struct cmd_list_element *c; 1179 register enum language flang; 1180 static int warned = 0; 1181 /* FIXME: These should really be in an appropriate header file */ 1182 extern void serial_log_command PARAMS ((const char *)); 1183 1184 free_all_values (); 1185 1186 /* This can happen when command_line_input hits end of file. */ 1187 if (p == NULL) 1188 return; 1189 1190 serial_log_command (p); 1191 1192 while (*p == ' ' || *p == '\t') p++; 1193 if (*p) 1194 { 1195 char *arg; 1196 1197 c = lookup_cmd (&p, cmdlist, "", 0, 1); 1198 /* Pass null arg rather than an empty one. */ 1199 arg = *p ? p : 0; 1200 1201 /* Clear off trailing whitespace, except for set and complete command. */ 1202 if (arg && c->type != set_cmd && c->function.cfunc != complete_command) 1203 { 1204 p = arg + strlen (arg) - 1; 1205 while (p >= arg && (*p == ' ' || *p == '\t')) 1206 p--; 1207 *(p + 1) = '\0'; 1208 } 1209 1210 /* If this command has been hooked, run the hook first. */ 1211 if (c->hook) 1212 execute_user_command (c->hook, (char *)0); 1213 1214 if (c->class == class_user) 1215 execute_user_command (c, arg); 1216 else if (c->type == set_cmd || c->type == show_cmd) 1217 do_setshow_command (arg, from_tty & caution, c); 1218 else if (c->function.cfunc == NO_FUNCTION) 1219 error ("That is not a command, just a help topic."); 1220 else if (call_command_hook) 1221 call_command_hook (c, arg, from_tty & caution); 1222 else 1223 (*c->function.cfunc) (arg, from_tty & caution); 1224 } 1225 1226 /* Tell the user if the language has changed (except first time). */ 1227 if (current_language != expected_language) 1228 { 1229 if (language_mode == language_mode_auto) { 1230 language_info (1); /* Print what changed. */ 1231 } 1232 warned = 0; 1233 } 1234 1235 /* Warn the user if the working language does not match the 1236 language of the current frame. Only warn the user if we are 1237 actually running the program, i.e. there is a stack. */ 1238 /* FIXME: This should be cacheing the frame and only running when 1239 the frame changes. */ 1240 1241 if (target_has_stack) 1242 { 1243 flang = get_frame_language (); 1244 if (!warned 1245 && flang != language_unknown 1246 && flang != current_language->la_language) 1247 { 1248 printf_filtered ("%s\n", lang_frame_mismatch_warn); 1249 warned = 1; 1250 } 1251 } 1252 } 1253 1254 /* ARGSUSED */ 1255 static void 1256 command_loop_marker (foo) 1257 int foo; 1258 { 1259 } 1260 1261 /* Read commands from `instream' and execute them 1262 until end of file or error reading instream. */ 1263 1264 void 1265 command_loop () 1266 { 1267 struct cleanup *old_chain; 1268 char *command; 1269 int stdin_is_tty = ISATTY (stdin); 1270 long time_at_cmd_start; 1271 #ifdef HAVE_SBRK 1272 long space_at_cmd_start; 1273 #endif 1274 extern int display_time; 1275 extern int display_space; 1276 1277 while (instream && !feof (instream)) 1278 { 1279 if (window_hook && instream == stdin) 1280 (*window_hook) (instream, prompt); 1281 1282 quit_flag = 0; 1283 if (instream == stdin && stdin_is_tty) 1284 reinitialize_more_filter (); 1285 old_chain = make_cleanup (command_loop_marker, 0); 1286 command = command_line_input (instream == stdin ? prompt : (char *) NULL, 1287 instream == stdin, "prompt"); 1288 if (command == 0) 1289 return; 1290 1291 time_at_cmd_start = get_run_time (); 1292 1293 if (display_space) 1294 { 1295 #ifdef HAVE_SBRK 1296 extern char **environ; 1297 char *lim = (char *) sbrk (0); 1298 1299 space_at_cmd_start = (long) (lim - (char *) &environ); 1300 #endif 1301 } 1302 1303 execute_command (command, instream == stdin); 1304 /* Do any commands attached to breakpoint we stopped at. */ 1305 bpstat_do_actions (&stop_bpstat); 1306 do_cleanups (old_chain); 1307 1308 if (display_time) 1309 { 1310 long cmd_time = get_run_time () - time_at_cmd_start; 1311 1312 printf_unfiltered ("Command execution time: %ld.%06ld\n", 1313 cmd_time / 1000000, cmd_time % 1000000); 1314 } 1315 1316 if (display_space) 1317 { 1318 #ifdef HAVE_SBRK 1319 extern char **environ; 1320 char *lim = (char *) sbrk (0); 1321 long space_now = lim - (char *) &environ; 1322 long space_diff = space_now - space_at_cmd_start; 1323 1324 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n", 1325 space_now, 1326 (space_diff >= 0 ? '+' : '-'), 1327 space_diff); 1328 #endif 1329 } 1330 } 1331 } 1332 1333 /* Commands call this if they do not want to be repeated by null lines. */ 1334 1335 void 1336 dont_repeat () 1337 { 1338 if (server_command) 1339 return; 1340 1341 /* If we aren't reading from standard input, we are saving the last 1342 thing read from stdin in line and don't want to delete it. Null lines 1343 won't repeat here in any case. */ 1344 if (instream == stdin) 1345 *line = 0; 1346 } 1347 1348 /* Read a line from the stream "instream" without command line editing. 1349 1350 It prints PRROMPT once at the start. 1351 Action is compatible with "readline", e.g. space for the result is 1352 malloc'd and should be freed by the caller. 1353 1354 A NULL return means end of file. */ 1355 char * 1356 gdb_readline (prrompt) 1357 char *prrompt; 1358 { 1359 int c; 1360 char *result; 1361 int input_index = 0; 1362 int result_size = 80; 1363 1364 if (prrompt) 1365 { 1366 /* Don't use a _filtered function here. It causes the assumed 1367 character position to be off, since the newline we read from 1368 the user is not accounted for. */ 1369 fputs_unfiltered (prrompt, gdb_stdout); 1370 #ifdef MPW 1371 /* Move to a new line so the entered line doesn't have a prompt 1372 on the front of it. */ 1373 fputs_unfiltered ("\n", gdb_stdout); 1374 #endif /* MPW */ 1375 gdb_flush (gdb_stdout); 1376 } 1377 1378 result = (char *) xmalloc (result_size); 1379 1380 while (1) 1381 { 1382 /* Read from stdin if we are executing a user defined command. 1383 This is the right thing for prompt_for_continue, at least. */ 1384 c = fgetc (instream ? instream : stdin); 1385 1386 if (c == EOF) 1387 { 1388 if (input_index > 0) 1389 /* The last line does not end with a newline. Return it, and 1390 if we are called again fgetc will still return EOF and 1391 we'll return NULL then. */ 1392 break; 1393 free (result); 1394 return NULL; 1395 } 1396 1397 if (c == '\n') 1398 break; 1399 1400 result[input_index++] = c; 1401 while (input_index >= result_size) 1402 { 1403 result_size *= 2; 1404 result = (char *) xrealloc (result, result_size); 1405 } 1406 } 1407 1408 result[input_index++] = '\0'; 1409 return result; 1410 } 1411 1412 /* Variables which control command line editing and history 1413 substitution. These variables are given default values at the end 1414 of this file. */ 1415 static int command_editing_p; 1416 static int history_expansion_p; 1417 static int write_history_p; 1418 static int history_size; 1419 static char *history_filename; 1420 1421 /* readline uses the word breaks for two things: 1422 (1) In figuring out where to point the TEXT parameter to the 1423 rl_completion_entry_function. Since we don't use TEXT for much, 1424 it doesn't matter a lot what the word breaks are for this purpose, but 1425 it does affect how much stuff M-? lists. 1426 (2) If one of the matches contains a word break character, readline 1427 will quote it. That's why we switch between 1428 gdb_completer_word_break_characters and 1429 gdb_completer_command_word_break_characters. I'm not sure when 1430 we need this behavior (perhaps for funky characters in C++ symbols?). */ 1431 1432 /* Variables which are necessary for fancy command line editing. */ 1433 char *gdb_completer_word_break_characters = 1434 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-"; 1435 1436 /* When completing on command names, we remove '-' from the list of 1437 word break characters, since we use it in command names. If the 1438 readline library sees one in any of the current completion strings, 1439 it thinks that the string needs to be quoted and automatically supplies 1440 a leading quote. */ 1441 char *gdb_completer_command_word_break_characters = 1442 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,"; 1443 1444 /* Characters that can be used to quote completion strings. Note that we 1445 can't include '"' because the gdb C parser treats such quoted sequences 1446 as strings. */ 1447 char *gdb_completer_quote_characters = 1448 "'"; 1449 1450 /* Functions that are used as part of the fancy command line editing. */ 1451 1452 /* This can be used for functions which don't want to complete on symbols 1453 but don't want to complete on anything else either. */ 1454 /* ARGSUSED */ 1455 char ** 1456 noop_completer (text, prefix) 1457 char *text; 1458 char *prefix; 1459 { 1460 return NULL; 1461 } 1462 1463 /* Complete on filenames. */ 1464 char ** 1465 filename_completer (text, word) 1466 char *text; 1467 char *word; 1468 { 1469 /* From readline. */ 1470 extern char *filename_completion_function PARAMS ((char *, int)); 1471 int subsequent_name; 1472 char **return_val; 1473 int return_val_used; 1474 int return_val_alloced; 1475 1476 return_val_used = 0; 1477 /* Small for testing. */ 1478 return_val_alloced = 1; 1479 return_val = (char **) xmalloc (return_val_alloced * sizeof (char *)); 1480 1481 subsequent_name = 0; 1482 while (1) 1483 { 1484 char *p; 1485 p = filename_completion_function (text, subsequent_name); 1486 if (return_val_used >= return_val_alloced) 1487 { 1488 return_val_alloced *= 2; 1489 return_val = 1490 (char **) xrealloc (return_val, 1491 return_val_alloced * sizeof (char *)); 1492 } 1493 if (p == NULL) 1494 { 1495 return_val[return_val_used++] = p; 1496 break; 1497 } 1498 /* Like emacs, don't complete on old versions. Especially useful 1499 in the "source" command. */ 1500 if (p[strlen (p) - 1] == '~') 1501 continue; 1502 1503 { 1504 char *q; 1505 if (word == text) 1506 /* Return exactly p. */ 1507 return_val[return_val_used++] = p; 1508 else if (word > text) 1509 { 1510 /* Return some portion of p. */ 1511 q = xmalloc (strlen (p) + 5); 1512 strcpy (q, p + (word - text)); 1513 return_val[return_val_used++] = q; 1514 free (p); 1515 } 1516 else 1517 { 1518 /* Return some of TEXT plus p. */ 1519 q = xmalloc (strlen (p) + (text - word) + 5); 1520 strncpy (q, word, text - word); 1521 q[text - word] = '\0'; 1522 strcat (q, p); 1523 return_val[return_val_used++] = q; 1524 free (p); 1525 } 1526 } 1527 subsequent_name = 1; 1528 } 1529 #if 0 1530 /* There is no way to do this just long enough to affect quote inserting 1531 without also affecting the next completion. This should be fixed in 1532 readline. FIXME. */ 1533 /* Insure that readline does the right thing 1534 with respect to inserting quotes. */ 1535 rl_completer_word_break_characters = ""; 1536 #endif 1537 return return_val; 1538 } 1539 1540 /* Here are some useful test cases for completion. FIXME: These should 1541 be put in the test suite. They should be tested with both M-? and TAB. 1542 1543 "show output-" "radix" 1544 "show output" "-radix" 1545 "p" ambiguous (commands starting with p--path, print, printf, etc.) 1546 "p " ambiguous (all symbols) 1547 "info t foo" no completions 1548 "info t " no completions 1549 "info t" ambiguous ("info target", "info terminal", etc.) 1550 "info ajksdlfk" no completions 1551 "info ajksdlfk " no completions 1552 "info" " " 1553 "info " ambiguous (all info commands) 1554 "p \"a" no completions (string constant) 1555 "p 'a" ambiguous (all symbols starting with a) 1556 "p b-a" ambiguous (all symbols starting with a) 1557 "p b-" ambiguous (all symbols) 1558 "file Make" "file" (word break hard to screw up here) 1559 "file ../gdb.stabs/we" "ird" (needs to not break word at slash) 1560 */ 1561 1562 /* Generate completions one by one for the completer. Each time we are 1563 called return another potential completion to the caller. 1564 line_completion just completes on commands or passes the buck to the 1565 command's completer function, the stuff specific to symbol completion 1566 is in make_symbol_completion_list. 1567 1568 TEXT is the caller's idea of the "word" we are looking at. 1569 1570 MATCHES is the number of matches that have currently been collected from 1571 calling this completion function. When zero, then we need to initialize, 1572 otherwise the initialization has already taken place and we can just 1573 return the next potential completion string. 1574 1575 LINE_BUFFER is available to be looked at; it contains the entire text 1576 of the line. POINT is the offset in that line of the cursor. You 1577 should pretend that the line ends at POINT. 1578 1579 Returns NULL if there are no more completions, else a pointer to a string 1580 which is a possible completion, it is the caller's responsibility to 1581 free the string. */ 1582 1583 static char * 1584 line_completion_function (text, matches, line_buffer, point) 1585 char *text; 1586 int matches; 1587 char *line_buffer; 1588 int point; 1589 { 1590 static char **list = (char **)NULL; /* Cache of completions */ 1591 static int index; /* Next cached completion */ 1592 char *output = NULL; 1593 char *tmp_command, *p; 1594 /* Pointer within tmp_command which corresponds to text. */ 1595 char *word; 1596 struct cmd_list_element *c, *result_list; 1597 1598 if (matches == 0) 1599 { 1600 /* The caller is beginning to accumulate a new set of completions, so 1601 we need to find all of them now, and cache them for returning one at 1602 a time on future calls. */ 1603 1604 if (list) 1605 { 1606 /* Free the storage used by LIST, but not by the strings inside. 1607 This is because rl_complete_internal () frees the strings. */ 1608 free ((PTR)list); 1609 } 1610 list = 0; 1611 index = 0; 1612 1613 /* Choose the default set of word break characters to break completions. 1614 If we later find out that we are doing completions on command strings 1615 (as opposed to strings supplied by the individual command completer 1616 functions, which can be any string) then we will switch to the 1617 special word break set for command strings, which leaves out the 1618 '-' character used in some commands. */ 1619 1620 rl_completer_word_break_characters = 1621 gdb_completer_word_break_characters; 1622 1623 /* Decide whether to complete on a list of gdb commands or on symbols. */ 1624 tmp_command = (char *) alloca (point + 1); 1625 p = tmp_command; 1626 1627 strncpy (tmp_command, line_buffer, point); 1628 tmp_command[point] = '\0'; 1629 /* Since text always contains some number of characters leading up 1630 to point, we can find the equivalent position in tmp_command 1631 by subtracting that many characters from the end of tmp_command. */ 1632 word = tmp_command + point - strlen (text); 1633 1634 if (point == 0) 1635 { 1636 /* An empty line we want to consider ambiguous; that is, it 1637 could be any command. */ 1638 c = (struct cmd_list_element *) -1; 1639 result_list = 0; 1640 } 1641 else 1642 { 1643 c = lookup_cmd_1 (&p, cmdlist, &result_list, 1); 1644 } 1645 1646 /* Move p up to the next interesting thing. */ 1647 while (*p == ' ' || *p == '\t') 1648 { 1649 p++; 1650 } 1651 1652 if (!c) 1653 { 1654 /* It is an unrecognized command. So there are no 1655 possible completions. */ 1656 list = NULL; 1657 } 1658 else if (c == (struct cmd_list_element *) -1) 1659 { 1660 char *q; 1661 1662 /* lookup_cmd_1 advances p up to the first ambiguous thing, but 1663 doesn't advance over that thing itself. Do so now. */ 1664 q = p; 1665 while (*q && (isalnum (*q) || *q == '-' || *q == '_')) 1666 ++q; 1667 if (q != tmp_command + point) 1668 { 1669 /* There is something beyond the ambiguous 1670 command, so there are no possible completions. For 1671 example, "info t " or "info t foo" does not complete 1672 to anything, because "info t" can be "info target" or 1673 "info terminal". */ 1674 list = NULL; 1675 } 1676 else 1677 { 1678 /* We're trying to complete on the command which was ambiguous. 1679 This we can deal with. */ 1680 if (result_list) 1681 { 1682 list = complete_on_cmdlist (*result_list->prefixlist, p, 1683 word); 1684 } 1685 else 1686 { 1687 list = complete_on_cmdlist (cmdlist, p, word); 1688 } 1689 /* Insure that readline does the right thing with respect to 1690 inserting quotes. */ 1691 rl_completer_word_break_characters = 1692 gdb_completer_command_word_break_characters; 1693 } 1694 } 1695 else 1696 { 1697 /* We've recognized a full command. */ 1698 1699 if (p == tmp_command + point) 1700 { 1701 /* There is no non-whitespace in the line beyond the command. */ 1702 1703 if (p[-1] == ' ' || p[-1] == '\t') 1704 { 1705 /* The command is followed by whitespace; we need to complete 1706 on whatever comes after command. */ 1707 if (c->prefixlist) 1708 { 1709 /* It is a prefix command; what comes after it is 1710 a subcommand (e.g. "info "). */ 1711 list = complete_on_cmdlist (*c->prefixlist, p, word); 1712 1713 /* Insure that readline does the right thing 1714 with respect to inserting quotes. */ 1715 rl_completer_word_break_characters = 1716 gdb_completer_command_word_break_characters; 1717 } 1718 else if (c->enums) 1719 { 1720 list = complete_on_enum (c->enums, p, word); 1721 rl_completer_word_break_characters = 1722 gdb_completer_command_word_break_characters; 1723 } 1724 else 1725 { 1726 /* It is a normal command; what comes after it is 1727 completed by the command's completer function. */ 1728 list = (*c->completer) (p, word); 1729 } 1730 } 1731 else 1732 { 1733 /* The command is not followed by whitespace; we need to 1734 complete on the command itself. e.g. "p" which is a 1735 command itself but also can complete to "print", "ptype" 1736 etc. */ 1737 char *q; 1738 1739 /* Find the command we are completing on. */ 1740 q = p; 1741 while (q > tmp_command) 1742 { 1743 if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_') 1744 --q; 1745 else 1746 break; 1747 } 1748 1749 list = complete_on_cmdlist (result_list, q, word); 1750 1751 /* Insure that readline does the right thing 1752 with respect to inserting quotes. */ 1753 rl_completer_word_break_characters = 1754 gdb_completer_command_word_break_characters; 1755 } 1756 } 1757 else 1758 { 1759 /* There is non-whitespace beyond the command. */ 1760 1761 if (c->prefixlist && !c->allow_unknown) 1762 { 1763 /* It is an unrecognized subcommand of a prefix command, 1764 e.g. "info adsfkdj". */ 1765 list = NULL; 1766 } 1767 else if (c->enums) 1768 { 1769 list = complete_on_enum (c->enums, p, word); 1770 } 1771 else 1772 { 1773 /* It is a normal command. */ 1774 list = (*c->completer) (p, word); 1775 } 1776 } 1777 } 1778 } 1779 1780 /* If we found a list of potential completions during initialization then 1781 dole them out one at a time. The vector of completions is NULL 1782 terminated, so after returning the last one, return NULL (and continue 1783 to do so) each time we are called after that, until a new list is 1784 available. */ 1785 1786 if (list) 1787 { 1788 output = list[index]; 1789 if (output) 1790 { 1791 index++; 1792 } 1793 } 1794 1795 #if 0 1796 /* Can't do this because readline hasn't yet checked the word breaks 1797 for figuring out whether to insert a quote. */ 1798 if (output == NULL) 1799 /* Make sure the word break characters are set back to normal for the 1800 next time that readline tries to complete something. */ 1801 rl_completer_word_break_characters = 1802 gdb_completer_word_break_characters; 1803 #endif 1804 1805 return (output); 1806 } 1807 1808 /* Line completion interface function for readline. */ 1809 1810 static char * 1811 readline_line_completion_function (text, matches) 1812 char *text; 1813 int matches; 1814 { 1815 return line_completion_function (text, matches, rl_line_buffer, rl_point); 1816 } 1817 1818 /* Skip over a possibly quoted word (as defined by the quote characters 1819 and word break characters the completer uses). Returns pointer to the 1820 location after the "word". */ 1821 1822 char * 1823 skip_quoted (str) 1824 char *str; 1825 { 1826 char quote_char = '\0'; 1827 char *scan; 1828 1829 for (scan = str; *scan != '\0'; scan++) 1830 { 1831 if (quote_char != '\0') 1832 { 1833 /* Ignore everything until the matching close quote char */ 1834 if (*scan == quote_char) 1835 { 1836 /* Found matching close quote. */ 1837 scan++; 1838 break; 1839 } 1840 } 1841 else if (strchr (gdb_completer_quote_characters, *scan)) 1842 { 1843 /* Found start of a quoted string. */ 1844 quote_char = *scan; 1845 } 1846 else if (strchr (gdb_completer_word_break_characters, *scan)) 1847 { 1848 break; 1849 } 1850 } 1851 return (scan); 1852 } 1853 1854 1855 #ifdef STOP_SIGNAL 1856 static void 1857 stop_sig (signo) 1858 int signo; 1859 { 1860 #if STOP_SIGNAL == SIGTSTP 1861 signal (SIGTSTP, SIG_DFL); 1862 sigsetmask (0); 1863 kill (getpid (), SIGTSTP); 1864 signal (SIGTSTP, stop_sig); 1865 #else 1866 signal (STOP_SIGNAL, stop_sig); 1867 #endif 1868 printf_unfiltered ("%s", prompt); 1869 gdb_flush (gdb_stdout); 1870 1871 /* Forget about any previous command -- null line now will do nothing. */ 1872 dont_repeat (); 1873 } 1874 #endif /* STOP_SIGNAL */ 1875 1876 /* Initialize signal handlers. */ 1877 static void 1878 do_nothing (signo) 1879 int signo; 1880 { 1881 } 1882 1883 static void 1884 init_signals () 1885 { 1886 signal (SIGINT, request_quit); 1887 1888 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed 1889 to the inferior and breakpoints will be ignored. */ 1890 #ifdef SIGTRAP 1891 signal (SIGTRAP, SIG_DFL); 1892 #endif 1893 1894 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get 1895 passed to the inferior, which we don't want. It would be 1896 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but 1897 on BSD4.3 systems using vfork, that can affect the 1898 GDB process as well as the inferior (the signal handling tables 1899 might be in memory, shared between the two). Since we establish 1900 a handler for SIGQUIT, when we call exec it will set the signal 1901 to SIG_DFL for us. */ 1902 #ifndef _WIN32 1903 signal (SIGQUIT, do_nothing); 1904 if (signal (SIGHUP, do_nothing) != SIG_IGN) 1905 signal (SIGHUP, disconnect); 1906 #endif 1907 signal (SIGFPE, float_handler); 1908 1909 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER) 1910 signal (SIGWINCH, SIGWINCH_HANDLER); 1911 #endif 1912 } 1913 1914 /* Read one line from the command input stream `instream' 1915 into the local static buffer `linebuffer' (whose current length 1916 is `linelength'). 1917 The buffer is made bigger as necessary. 1918 Returns the address of the start of the line. 1919 1920 NULL is returned for end of file. 1921 1922 *If* the instream == stdin & stdin is a terminal, the line read 1923 is copied into the file line saver (global var char *line, 1924 length linesize) so that it can be duplicated. 1925 1926 This routine either uses fancy command line editing or 1927 simple input as the user has requested. */ 1928 1929 char * 1930 command_line_input (prrompt, repeat, annotation_suffix) 1931 char *prrompt; 1932 int repeat; 1933 char *annotation_suffix; 1934 { 1935 static char *linebuffer = 0; 1936 static unsigned linelength = 0; 1937 register char *p; 1938 char *p1; 1939 char *rl; 1940 char *local_prompt = prrompt; 1941 char *nline; 1942 char got_eof = 0; 1943 1944 /* The annotation suffix must be non-NULL. */ 1945 if (annotation_suffix == NULL) 1946 annotation_suffix = ""; 1947 1948 if (annotation_level > 1 && instream == stdin) 1949 { 1950 local_prompt = alloca ((prrompt == NULL ? 0 : strlen (prrompt)) 1951 + strlen (annotation_suffix) + 40); 1952 if (prrompt == NULL) 1953 local_prompt[0] = '\0'; 1954 else 1955 strcpy (local_prompt, prrompt); 1956 strcat (local_prompt, "\n\032\032"); 1957 strcat (local_prompt, annotation_suffix); 1958 strcat (local_prompt, "\n"); 1959 } 1960 1961 if (linebuffer == 0) 1962 { 1963 linelength = 80; 1964 linebuffer = (char *) xmalloc (linelength); 1965 } 1966 1967 p = linebuffer; 1968 1969 /* Control-C quits instantly if typed while in this loop 1970 since it should not wait until the user types a newline. */ 1971 immediate_quit++; 1972 #ifdef STOP_SIGNAL 1973 if (job_control) 1974 signal (STOP_SIGNAL, stop_sig); 1975 #endif 1976 1977 while (1) 1978 { 1979 /* Make sure that all output has been output. Some machines may let 1980 you get away with leaving out some of the gdb_flush, but not all. */ 1981 wrap_here (""); 1982 gdb_flush (gdb_stdout); 1983 gdb_flush (gdb_stderr); 1984 1985 if (source_file_name != NULL) 1986 { 1987 ++source_line_number; 1988 sprintf (source_error, 1989 "%s%s:%d: Error in sourced command file:\n", 1990 source_pre_error, 1991 source_file_name, 1992 source_line_number); 1993 error_pre_print = source_error; 1994 } 1995 1996 if (annotation_level > 1 && instream == stdin) 1997 { 1998 printf_unfiltered ("\n\032\032pre-"); 1999 printf_unfiltered (annotation_suffix); 2000 printf_unfiltered ("\n"); 2001 } 2002 2003 /* Don't use fancy stuff if not talking to stdin. */ 2004 if (readline_hook && instream == NULL) 2005 { 2006 rl = (*readline_hook) (local_prompt); 2007 } 2008 else if (command_editing_p && instream == stdin && ISATTY (instream)) 2009 { 2010 rl = readline (local_prompt); 2011 } 2012 else 2013 { 2014 rl = gdb_readline (local_prompt); 2015 } 2016 2017 if (annotation_level > 1 && instream == stdin) 2018 { 2019 printf_unfiltered ("\n\032\032post-"); 2020 printf_unfiltered (annotation_suffix); 2021 printf_unfiltered ("\n"); 2022 } 2023 2024 if (!rl || rl == (char *) EOF) 2025 { 2026 got_eof = 1; 2027 break; 2028 } 2029 if (strlen(rl) + 1 + (p - linebuffer) > linelength) 2030 { 2031 linelength = strlen(rl) + 1 + (p - linebuffer); 2032 nline = (char *) xrealloc (linebuffer, linelength); 2033 p += nline - linebuffer; 2034 linebuffer = nline; 2035 } 2036 p1 = rl; 2037 /* Copy line. Don't copy null at end. (Leaves line alone 2038 if this was just a newline) */ 2039 while (*p1) 2040 *p++ = *p1++; 2041 2042 free (rl); /* Allocated in readline. */ 2043 2044 if (p == linebuffer || *(p - 1) != '\\') 2045 break; 2046 2047 p--; /* Put on top of '\'. */ 2048 local_prompt = (char *) 0; 2049 } 2050 2051 #ifdef STOP_SIGNAL 2052 if (job_control) 2053 signal (STOP_SIGNAL, SIG_DFL); 2054 #endif 2055 immediate_quit--; 2056 2057 if (got_eof) 2058 return NULL; 2059 2060 #define SERVER_COMMAND_LENGTH 7 2061 server_command = 2062 (p - linebuffer > SERVER_COMMAND_LENGTH) 2063 && STREQN (linebuffer, "server ", SERVER_COMMAND_LENGTH); 2064 if (server_command) 2065 { 2066 /* Note that we don't set `line'. Between this and the check in 2067 dont_repeat, this insures that repeating will still do the 2068 right thing. */ 2069 *p = '\0'; 2070 return linebuffer + SERVER_COMMAND_LENGTH; 2071 } 2072 2073 /* Do history expansion if that is wished. */ 2074 if (history_expansion_p && instream == stdin 2075 && ISATTY (instream)) 2076 { 2077 char *history_value; 2078 int expanded; 2079 2080 *p = '\0'; /* Insert null now. */ 2081 expanded = history_expand (linebuffer, &history_value); 2082 if (expanded) 2083 { 2084 /* Print the changes. */ 2085 printf_unfiltered ("%s\n", history_value); 2086 2087 /* If there was an error, call this function again. */ 2088 if (expanded < 0) 2089 { 2090 free (history_value); 2091 return command_line_input (prrompt, repeat, annotation_suffix); 2092 } 2093 if (strlen (history_value) > linelength) 2094 { 2095 linelength = strlen (history_value) + 1; 2096 linebuffer = (char *) xrealloc (linebuffer, linelength); 2097 } 2098 strcpy (linebuffer, history_value); 2099 p = linebuffer + strlen(linebuffer); 2100 free (history_value); 2101 } 2102 } 2103 2104 /* If we just got an empty line, and that is supposed 2105 to repeat the previous command, return the value in the 2106 global buffer. */ 2107 if (repeat && p == linebuffer) 2108 return line; 2109 for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++) ; 2110 if (repeat && !*p1) 2111 return line; 2112 2113 *p = 0; 2114 2115 /* Add line to history if appropriate. */ 2116 if (instream == stdin 2117 && ISATTY (stdin) && *linebuffer) 2118 add_history (linebuffer); 2119 2120 /* Note: lines consisting solely of comments are added to the command 2121 history. This is useful when you type a command, and then 2122 realize you don't want to execute it quite yet. You can comment 2123 out the command and then later fetch it from the value history 2124 and remove the '#'. The kill ring is probably better, but some 2125 people are in the habit of commenting things out. */ 2126 if (*p1 == '#') 2127 *p1 = '\0'; /* Found a comment. */ 2128 2129 /* Save into global buffer if appropriate. */ 2130 if (repeat) 2131 { 2132 if (linelength > linesize) 2133 { 2134 line = xrealloc (line, linelength); 2135 linesize = linelength; 2136 } 2137 strcpy (line, linebuffer); 2138 return line; 2139 } 2140 2141 return linebuffer; 2142 } 2143 2144 2145 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH 2146 code bodies. This is typically used when we encounter an "else" 2147 clause for an "if" command. */ 2148 2149 static void 2150 realloc_body_list (command, new_length) 2151 struct command_line *command; 2152 int new_length; 2153 { 2154 int n; 2155 struct command_line **body_list; 2156 2157 n = command->body_count; 2158 2159 /* Nothing to do? */ 2160 if (new_length <= n) 2161 return; 2162 2163 body_list = (struct command_line **) 2164 xmalloc (sizeof (struct command_line *) * new_length); 2165 2166 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n); 2167 2168 free (command->body_list); 2169 command->body_list = body_list; 2170 command->body_count = new_length; 2171 } 2172 2173 /* Read one line from the input stream. If the command is an "else" or 2174 "end", return such an indication to the caller. */ 2175 2176 static enum misc_command_type 2177 read_next_line (command) 2178 struct command_line **command; 2179 { 2180 char *p, *p1, *prompt_ptr, control_prompt[256]; 2181 int i = 0; 2182 2183 if (control_level >= 254) 2184 error ("Control nesting too deep!\n"); 2185 2186 /* Set a prompt based on the nesting of the control commands. */ 2187 if (instream == stdin || (instream == 0 && readline_hook != NULL)) 2188 { 2189 for (i = 0; i < control_level; i++) 2190 control_prompt[i] = ' '; 2191 control_prompt[i] = '>'; 2192 control_prompt[i+1] = '\0'; 2193 prompt_ptr = (char *)&control_prompt[0]; 2194 } 2195 else 2196 prompt_ptr = NULL; 2197 2198 p = command_line_input (prompt_ptr, instream == stdin, "commands"); 2199 2200 /* Not sure what to do here. */ 2201 if (p == NULL) 2202 return end_command; 2203 2204 /* Strip leading and trailing whitespace. */ 2205 while (*p == ' ' || *p == '\t') 2206 p++; 2207 2208 p1 = p + strlen (p); 2209 while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t')) 2210 p1--; 2211 2212 /* Blanks and comments don't really do anything, but we need to 2213 distinguish them from else, end and other commands which can be 2214 executed. */ 2215 if (p1 == p || p[0] == '#') 2216 return nop_command; 2217 2218 /* Is this the end of a simple, while, or if control structure? */ 2219 if (p1 - p == 3 && !strncmp (p, "end", 3)) 2220 return end_command; 2221 2222 /* Is the else clause of an if control structure? */ 2223 if (p1 - p == 4 && !strncmp (p, "else", 4)) 2224 return else_command; 2225 2226 /* Check for while, if, break, continue, etc and build a new command 2227 line structure for them. */ 2228 if (p1 - p > 5 && !strncmp (p, "while", 5)) 2229 *command = build_command_line (while_control, p + 6); 2230 else if (p1 - p > 2 && !strncmp (p, "if", 2)) 2231 *command = build_command_line (if_control, p + 3); 2232 else if (p1 - p == 10 && !strncmp (p, "loop_break", 10)) 2233 { 2234 *command = (struct command_line *) 2235 xmalloc (sizeof (struct command_line)); 2236 (*command)->next = NULL; 2237 (*command)->line = NULL; 2238 (*command)->control_type = break_control; 2239 (*command)->body_count = 0; 2240 (*command)->body_list = NULL; 2241 } 2242 else if (p1 - p == 13 && !strncmp (p, "loop_continue", 13)) 2243 { 2244 *command = (struct command_line *) 2245 xmalloc (sizeof (struct command_line)); 2246 (*command)->next = NULL; 2247 (*command)->line = NULL; 2248 (*command)->control_type = continue_control; 2249 (*command)->body_count = 0; 2250 (*command)->body_list = NULL; 2251 } 2252 else 2253 { 2254 /* A normal command. */ 2255 *command = (struct command_line *) 2256 xmalloc (sizeof (struct command_line)); 2257 (*command)->next = NULL; 2258 (*command)->line = savestring (p, p1 - p); 2259 (*command)->control_type = simple_control; 2260 (*command)->body_count = 0; 2261 (*command)->body_list = NULL; 2262 } 2263 2264 /* Nothing special. */ 2265 return ok_command; 2266 } 2267 2268 /* Recursively read in the control structures and create a command_line 2269 structure from them. 2270 2271 The parent_control parameter is the control structure in which the 2272 following commands are nested. */ 2273 2274 static enum command_control_type 2275 recurse_read_control_structure (current_cmd) 2276 struct command_line *current_cmd; 2277 { 2278 int current_body, i; 2279 enum misc_command_type val; 2280 enum command_control_type ret; 2281 struct command_line **body_ptr, *child_tail, *next; 2282 2283 child_tail = NULL; 2284 current_body = 1; 2285 2286 /* Sanity checks. */ 2287 if (current_cmd->control_type == simple_control) 2288 { 2289 error ("Recursed on a simple control type\n"); 2290 return invalid_control; 2291 } 2292 2293 if (current_body > current_cmd->body_count) 2294 { 2295 error ("Allocated body is smaller than this command type needs\n"); 2296 return invalid_control; 2297 } 2298 2299 /* Read lines from the input stream and build control structures. */ 2300 while (1) 2301 { 2302 dont_repeat (); 2303 2304 next = NULL; 2305 val = read_next_line (&next); 2306 2307 /* Just skip blanks and comments. */ 2308 if (val == nop_command) 2309 continue; 2310 2311 if (val == end_command) 2312 { 2313 if (current_cmd->control_type == while_control 2314 || current_cmd->control_type == if_control) 2315 { 2316 /* Success reading an entire control structure. */ 2317 ret = simple_control; 2318 break; 2319 } 2320 else 2321 { 2322 ret = invalid_control; 2323 break; 2324 } 2325 } 2326 2327 /* Not the end of a control structure. */ 2328 if (val == else_command) 2329 { 2330 if (current_cmd->control_type == if_control 2331 && current_body == 1) 2332 { 2333 realloc_body_list (current_cmd, 2); 2334 current_body = 2; 2335 child_tail = NULL; 2336 continue; 2337 } 2338 else 2339 { 2340 ret = invalid_control; 2341 break; 2342 } 2343 } 2344 2345 if (child_tail) 2346 { 2347 child_tail->next = next; 2348 } 2349 else 2350 { 2351 body_ptr = current_cmd->body_list; 2352 for (i = 1; i < current_body; i++) 2353 body_ptr++; 2354 2355 *body_ptr = next; 2356 2357 } 2358 2359 child_tail = next; 2360 2361 /* If the latest line is another control structure, then recurse 2362 on it. */ 2363 if (next->control_type == while_control 2364 || next->control_type == if_control) 2365 { 2366 control_level++; 2367 ret = recurse_read_control_structure (next); 2368 control_level--; 2369 2370 if (ret != simple_control) 2371 break; 2372 } 2373 } 2374 2375 dont_repeat (); 2376 2377 return ret; 2378 } 2379 2380 /* Read lines from the input stream and accumulate them in a chain of 2381 struct command_line's, which is then returned. For input from a 2382 terminal, the special command "end" is used to mark the end of the 2383 input, and is not included in the returned chain of commands. */ 2384 2385 #define END_MESSAGE "End with a line saying just \"end\"." 2386 2387 struct command_line * 2388 read_command_lines (prompt, from_tty) 2389 char *prompt; 2390 int from_tty; 2391 { 2392 struct command_line *head, *tail, *next; 2393 struct cleanup *old_chain; 2394 enum command_control_type ret; 2395 enum misc_command_type val; 2396 2397 if (readline_begin_hook) 2398 { 2399 /* Note - intentional to merge messages with no newline */ 2400 (*readline_begin_hook) ("%s %s\n", prompt, END_MESSAGE); 2401 } 2402 else if (from_tty && input_from_terminal_p ()) 2403 { 2404 printf_unfiltered ("%s\n%s\n", prompt, END_MESSAGE); 2405 gdb_flush (gdb_stdout); 2406 } 2407 2408 head = tail = NULL; 2409 old_chain = NULL; 2410 2411 while (1) 2412 { 2413 val = read_next_line (&next); 2414 2415 /* Ignore blank lines or comments. */ 2416 if (val == nop_command) 2417 continue; 2418 2419 if (val == end_command) 2420 { 2421 ret = simple_control; 2422 break; 2423 } 2424 2425 if (val != ok_command) 2426 { 2427 ret = invalid_control; 2428 break; 2429 } 2430 2431 if (next->control_type == while_control 2432 || next->control_type == if_control) 2433 { 2434 control_level++; 2435 ret = recurse_read_control_structure (next); 2436 control_level--; 2437 2438 if (ret == invalid_control) 2439 break; 2440 } 2441 2442 if (tail) 2443 { 2444 tail->next = next; 2445 } 2446 else 2447 { 2448 head = next; 2449 old_chain = make_cleanup (free_command_lines, &head); 2450 } 2451 tail = next; 2452 } 2453 2454 dont_repeat (); 2455 2456 if (head) 2457 { 2458 if (ret != invalid_control) 2459 { 2460 discard_cleanups (old_chain); 2461 } 2462 else 2463 do_cleanups (old_chain); 2464 } 2465 2466 if (readline_end_hook) 2467 { 2468 (*readline_end_hook) (); 2469 } 2470 return (head); 2471 } 2472 2473 /* Free a chain of struct command_line's. */ 2474 2475 void 2476 free_command_lines (lptr) 2477 struct command_line **lptr; 2478 { 2479 register struct command_line *l = *lptr; 2480 register struct command_line *next; 2481 struct command_line **blist; 2482 int i; 2483 2484 while (l) 2485 { 2486 if (l->body_count > 0) 2487 { 2488 blist = l->body_list; 2489 for (i = 0; i < l->body_count; i++, blist++) 2490 free_command_lines (blist); 2491 } 2492 next = l->next; 2493 free (l->line); 2494 free ((PTR)l); 2495 l = next; 2496 } 2497 } 2498 2499 /* Add an element to the list of info subcommands. */ 2500 2501 void 2502 add_info (name, fun, doc) 2503 char *name; 2504 void (*fun) PARAMS ((char *, int)); 2505 char *doc; 2506 { 2507 add_cmd (name, no_class, fun, doc, &infolist); 2508 } 2509 2510 /* Add an alias to the list of info subcommands. */ 2511 2512 void 2513 add_info_alias (name, oldname, abbrev_flag) 2514 char *name; 2515 char *oldname; 2516 int abbrev_flag; 2517 { 2518 add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist); 2519 } 2520 2521 /* The "info" command is defined as a prefix, with allow_unknown = 0. 2522 Therefore, its own definition is called only for "info" with no args. */ 2523 2524 /* ARGSUSED */ 2525 static void 2526 info_command (arg, from_tty) 2527 char *arg; 2528 int from_tty; 2529 { 2530 printf_unfiltered ("\"info\" must be followed by the name of an info command.\n"); 2531 help_list (infolist, "info ", -1, gdb_stdout); 2532 } 2533 2534 /* The "complete" command is used by Emacs to implement completion. */ 2535 2536 /* ARGSUSED */ 2537 static void 2538 complete_command (arg, from_tty) 2539 char *arg; 2540 int from_tty; 2541 { 2542 int i; 2543 int argpoint; 2544 char *completion; 2545 2546 dont_repeat (); 2547 2548 if (arg == NULL) 2549 arg = ""; 2550 argpoint = strlen (arg); 2551 2552 for (completion = line_completion_function (arg, i = 0, arg, argpoint); 2553 completion; 2554 completion = line_completion_function (arg, ++i, arg, argpoint)) 2555 { 2556 printf_unfiltered ("%s\n", completion); 2557 free (completion); 2558 } 2559 } 2560 2561 /* The "show" command with no arguments shows all the settings. */ 2562 2563 /* ARGSUSED */ 2564 static void 2565 show_command (arg, from_tty) 2566 char *arg; 2567 int from_tty; 2568 { 2569 cmd_show_list (showlist, from_tty, ""); 2570 } 2571 2572 /* Add an element to the list of commands. */ 2573 2574 void 2575 add_com (name, class, fun, doc) 2576 char *name; 2577 enum command_class class; 2578 void (*fun) PARAMS ((char *, int)); 2579 char *doc; 2580 { 2581 add_cmd (name, class, fun, doc, &cmdlist); 2582 } 2583 2584 /* Add an alias or abbreviation command to the list of commands. */ 2585 2586 void 2587 add_com_alias (name, oldname, class, abbrev_flag) 2588 char *name; 2589 char *oldname; 2590 enum command_class class; 2591 int abbrev_flag; 2592 { 2593 add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist); 2594 } 2595 2596 void 2597 error_no_arg (why) 2598 char *why; 2599 { 2600 error ("Argument required (%s).", why); 2601 } 2602 2603 /* ARGSUSED */ 2604 static void 2605 help_command (command, from_tty) 2606 char *command; 2607 int from_tty; /* Ignored */ 2608 { 2609 help_cmd (command, gdb_stdout); 2610 } 2611 2612 static void 2613 validate_comname (comname) 2614 char *comname; 2615 { 2616 register char *p; 2617 2618 if (comname == 0) 2619 error_no_arg ("name of command to define"); 2620 2621 p = comname; 2622 while (*p) 2623 { 2624 if (!isalnum(*p) && *p != '-' && *p != '_') 2625 error ("Junk in argument list: \"%s\"", p); 2626 p++; 2627 } 2628 } 2629 2630 /* This is just a placeholder in the command data structures. */ 2631 static void 2632 user_defined_command (ignore, from_tty) 2633 char *ignore; 2634 int from_tty; 2635 { 2636 } 2637 2638 static void 2639 define_command (comname, from_tty) 2640 char *comname; 2641 int from_tty; 2642 { 2643 register struct command_line *cmds; 2644 register struct cmd_list_element *c, *newc, *hookc = 0; 2645 char *tem = comname; 2646 char tmpbuf[128]; 2647 #define HOOK_STRING "hook-" 2648 #define HOOK_LEN 5 2649 2650 validate_comname (comname); 2651 2652 /* Look it up, and verify that we got an exact match. */ 2653 c = lookup_cmd (&tem, cmdlist, "", -1, 1); 2654 if (c && !STREQ (comname, c->name)) 2655 c = 0; 2656 2657 if (c) 2658 { 2659 if (c->class == class_user || c->class == class_alias) 2660 tem = "Redefine command \"%s\"? "; 2661 else 2662 tem = "Really redefine built-in command \"%s\"? "; 2663 if (!query (tem, c->name)) 2664 error ("Command \"%s\" not redefined.", c->name); 2665 } 2666 2667 /* If this new command is a hook, then mark the command which it 2668 is hooking. Note that we allow hooking `help' commands, so that 2669 we can hook the `stop' pseudo-command. */ 2670 2671 if (!strncmp (comname, HOOK_STRING, HOOK_LEN)) 2672 { 2673 /* Look up cmd it hooks, and verify that we got an exact match. */ 2674 tem = comname+HOOK_LEN; 2675 hookc = lookup_cmd (&tem, cmdlist, "", -1, 0); 2676 if (hookc && !STREQ (comname+HOOK_LEN, hookc->name)) 2677 hookc = 0; 2678 if (!hookc) 2679 { 2680 warning ("Your new `%s' command does not hook any existing command.", 2681 comname); 2682 if (!query ("Proceed? ")) 2683 error ("Not confirmed."); 2684 } 2685 } 2686 2687 comname = savestring (comname, strlen (comname)); 2688 2689 /* If the rest of the commands will be case insensitive, this one 2690 should behave in the same manner. */ 2691 for (tem = comname; *tem; tem++) 2692 if (isupper(*tem)) *tem = tolower(*tem); 2693 2694 control_level = 0; 2695 sprintf (tmpbuf, "Type commands for definition of \"%s\".", comname); 2696 cmds = read_command_lines (tmpbuf, from_tty); 2697 2698 if (c && c->class == class_user) 2699 free_command_lines (&c->user_commands); 2700 2701 newc = add_cmd (comname, class_user, user_defined_command, 2702 (c && c->class == class_user) 2703 ? c->doc : savestring ("User-defined.", 13), &cmdlist); 2704 newc->user_commands = cmds; 2705 2706 /* If this new command is a hook, then mark both commands as being 2707 tied. */ 2708 if (hookc) 2709 { 2710 hookc->hook = newc; /* Target gets hooked. */ 2711 newc->hookee = hookc; /* We are marked as hooking target cmd. */ 2712 } 2713 } 2714 2715 static void 2716 document_command (comname, from_tty) 2717 char *comname; 2718 int from_tty; 2719 { 2720 struct command_line *doclines; 2721 register struct cmd_list_element *c; 2722 char *tem = comname; 2723 char tmpbuf[128]; 2724 2725 validate_comname (comname); 2726 2727 c = lookup_cmd (&tem, cmdlist, "", 0, 1); 2728 2729 if (c->class != class_user) 2730 error ("Command \"%s\" is built-in.", comname); 2731 2732 sprintf (tmpbuf, "Type documentation for \"%s\".", comname); 2733 doclines = read_command_lines (tmpbuf, from_tty); 2734 2735 if (c->doc) free (c->doc); 2736 2737 { 2738 register struct command_line *cl1; 2739 register int len = 0; 2740 2741 for (cl1 = doclines; cl1; cl1 = cl1->next) 2742 len += strlen (cl1->line) + 1; 2743 2744 c->doc = (char *) xmalloc (len + 1); 2745 *c->doc = 0; 2746 2747 for (cl1 = doclines; cl1; cl1 = cl1->next) 2748 { 2749 strcat (c->doc, cl1->line); 2750 if (cl1->next) 2751 strcat (c->doc, "\n"); 2752 } 2753 } 2754 2755 free_command_lines (&doclines); 2756 } 2757 2758 void 2759 print_gdb_version (stream) 2760 GDB_FILE *stream; 2761 { 2762 /* From GNU coding standards, first line is meant to be easy for a 2763 program to parse, and is just canonical program name and version 2764 number, which starts after last space. */ 2765 2766 fprintf_filtered (stream, "GNU gdb %s\n", version); 2767 2768 /* Second line is a copyright notice. */ 2769 2770 fprintf_filtered (stream, "Copyright 1996 Free Software Foundation, Inc.\n"); 2771 2772 /* Following the copyright is a brief statement that the program is 2773 free software, that users are free to copy and change it on 2774 certain conditions, that it is covered by the GNU GPL, and that 2775 there is no warranty. */ 2776 2777 fprintf_filtered (stream, "\ 2778 GDB is free software, covered by the GNU General Public License, and you are\n\ 2779 welcome to change it and/or distribute copies of it under certain conditions.\n\ 2780 Type \"show copying\" to see the conditions.\n\ 2781 There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n"); 2782 2783 /* After the required info we print the configuration information. */ 2784 2785 fprintf_filtered (stream, "This GDB was configured as \""); 2786 if (!STREQ (host_name, target_name)) 2787 { 2788 fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name); 2789 } 2790 else 2791 { 2792 fprintf_filtered (stream, "%s", host_name); 2793 } 2794 fprintf_filtered (stream, "\"."); 2795 } 2796 2797 /* ARGSUSED */ 2798 static void 2799 show_version (args, from_tty) 2800 char *args; 2801 int from_tty; 2802 { 2803 immediate_quit++; 2804 print_gdb_version (gdb_stdout); 2805 printf_filtered ("\n"); 2806 immediate_quit--; 2807 } 2808 2809 /* xgdb calls this to reprint the usual GDB prompt. Obsolete now that xgdb 2810 is obsolete. */ 2811 2812 void 2813 print_prompt () 2814 { 2815 printf_unfiltered ("%s", prompt); 2816 gdb_flush (gdb_stdout); 2817 } 2818 2819 void 2820 quit_command (args, from_tty) 2821 char *args; 2822 int from_tty; 2823 { 2824 int exit_code = 0; 2825 2826 /* An optional expression may be used to cause gdb to terminate with the 2827 value of that expression. */ 2828 if (args) 2829 { 2830 value_ptr val = parse_and_eval (args); 2831 2832 exit_code = (int) value_as_long (val); 2833 } 2834 2835 if (inferior_pid != 0 && target_has_execution) 2836 { 2837 if (attach_flag) 2838 { 2839 if (query ("The program is running. Quit anyway (and detach it)? ")) 2840 target_detach (args, from_tty); 2841 else 2842 error ("Not confirmed."); 2843 } 2844 else 2845 { 2846 if (query ("The program is running. Quit anyway (and kill it)? ")) 2847 target_kill (); 2848 else 2849 error ("Not confirmed."); 2850 } 2851 } 2852 /* UDI wants this, to kill the TIP. */ 2853 target_close (1); 2854 2855 /* Save the history information if it is appropriate to do so. */ 2856 if (write_history_p && history_filename) 2857 write_history (history_filename); 2858 2859 exit (exit_code); 2860 } 2861 2862 /* Returns whether GDB is running on a terminal and whether the user 2863 desires that questions be asked of them on that terminal. */ 2864 2865 int 2866 input_from_terminal_p () 2867 { 2868 return gdb_has_a_terminal () && (instream == stdin) & caution; 2869 } 2870 2871 /* ARGSUSED */ 2872 static void 2873 pwd_command (args, from_tty) 2874 char *args; 2875 int from_tty; 2876 { 2877 if (args) error ("The \"pwd\" command does not take an argument: %s", args); 2878 getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)); 2879 2880 if (!STREQ (gdb_dirbuf, current_directory)) 2881 printf_unfiltered ("Working directory %s\n (canonically %s).\n", 2882 current_directory, gdb_dirbuf); 2883 else 2884 printf_unfiltered ("Working directory %s.\n", current_directory); 2885 } 2886 2887 void 2888 cd_command (dir, from_tty) 2889 char *dir; 2890 int from_tty; 2891 { 2892 int len; 2893 /* Found something other than leading repetitions of "/..". */ 2894 int found_real_path; 2895 char *p; 2896 2897 /* If the new directory is absolute, repeat is a no-op; if relative, 2898 repeat might be useful but is more likely to be a mistake. */ 2899 dont_repeat (); 2900 2901 if (dir == 0) 2902 error_no_arg ("new working directory"); 2903 2904 dir = tilde_expand (dir); 2905 make_cleanup (free, dir); 2906 2907 if (chdir (dir) < 0) 2908 perror_with_name (dir); 2909 2910 len = strlen (dir); 2911 dir = savestring (dir, len - (len > 1 && SLASH_P(dir[len-1]))); 2912 if (ROOTED_P(dir)) 2913 current_directory = dir; 2914 else 2915 { 2916 if (SLASH_P (current_directory[0]) && current_directory[1] == '\0') 2917 current_directory = concat (current_directory, dir, NULL); 2918 else 2919 current_directory = concat (current_directory, SLASH_STRING, dir, NULL); 2920 free (dir); 2921 } 2922 2923 /* Now simplify any occurrences of `.' and `..' in the pathname. */ 2924 2925 found_real_path = 0; 2926 for (p = current_directory; *p;) 2927 { 2928 if (SLASH_P (p[0]) && p[1] == '.' && (p[2] == 0 || SLASH_P (p[2]))) 2929 strcpy (p, p + 2); 2930 else if (SLASH_P (p[0]) && p[1] == '.' && p[2] == '.' 2931 && (p[3] == 0 || SLASH_P (p[3]))) 2932 { 2933 if (found_real_path) 2934 { 2935 /* Search backwards for the directory just before the "/.." 2936 and obliterate it and the "/..". */ 2937 char *q = p; 2938 while (q != current_directory && ! SLASH_P (q[-1])) 2939 --q; 2940 2941 if (q == current_directory) 2942 /* current_directory is 2943 a relative pathname ("can't happen"--leave it alone). */ 2944 ++p; 2945 else 2946 { 2947 strcpy (q - 1, p + 3); 2948 p = q - 1; 2949 } 2950 } 2951 else 2952 /* We are dealing with leading repetitions of "/..", for example 2953 "/../..", which is the Mach super-root. */ 2954 p += 3; 2955 } 2956 else 2957 { 2958 found_real_path = 1; 2959 ++p; 2960 } 2961 } 2962 2963 forget_cached_source_info (); 2964 2965 if (from_tty) 2966 pwd_command ((char *) 0, 1); 2967 } 2968 2969 struct source_cleanup_lines_args { 2970 int old_line; 2971 char *old_file; 2972 char *old_pre_error; 2973 char *old_error_pre_print; 2974 }; 2975 2976 static void 2977 source_cleanup_lines (args) 2978 PTR args; 2979 { 2980 struct source_cleanup_lines_args *p = 2981 (struct source_cleanup_lines_args *)args; 2982 source_line_number = p->old_line; 2983 source_file_name = p->old_file; 2984 source_pre_error = p->old_pre_error; 2985 error_pre_print = p->old_error_pre_print; 2986 } 2987 2988 /* ARGSUSED */ 2989 void 2990 source_command (args, from_tty) 2991 char *args; 2992 int from_tty; 2993 { 2994 FILE *stream; 2995 struct cleanup *old_cleanups; 2996 char *file = args; 2997 struct source_cleanup_lines_args old_lines; 2998 int needed_length; 2999 3000 if (file == NULL) 3001 { 3002 error ("source command requires pathname of file to source."); 3003 } 3004 3005 file = tilde_expand (file); 3006 old_cleanups = make_cleanup (free, file); 3007 3008 stream = fopen (file, FOPEN_RT); 3009 if (!stream) 3010 if (from_tty) 3011 perror_with_name (file); 3012 else 3013 return; 3014 3015 make_cleanup (fclose, stream); 3016 3017 old_lines.old_line = source_line_number; 3018 old_lines.old_file = source_file_name; 3019 old_lines.old_pre_error = source_pre_error; 3020 old_lines.old_error_pre_print = error_pre_print; 3021 make_cleanup (source_cleanup_lines, &old_lines); 3022 source_line_number = 0; 3023 source_file_name = file; 3024 source_pre_error = error_pre_print == NULL ? "" : error_pre_print; 3025 source_pre_error = savestring (source_pre_error, strlen (source_pre_error)); 3026 make_cleanup (free, source_pre_error); 3027 /* This will get set every time we read a line. So it won't stay "" for 3028 long. */ 3029 error_pre_print = ""; 3030 3031 needed_length = strlen (source_file_name) + strlen (source_pre_error) + 80; 3032 if (source_error_allocated < needed_length) 3033 { 3034 source_error_allocated *= 2; 3035 if (source_error_allocated < needed_length) 3036 source_error_allocated = needed_length; 3037 if (source_error == NULL) 3038 source_error = xmalloc (source_error_allocated); 3039 else 3040 source_error = xrealloc (source_error, source_error_allocated); 3041 } 3042 3043 read_command_file (stream); 3044 3045 do_cleanups (old_cleanups); 3046 } 3047 3048 /* ARGSUSED */ 3049 static void 3050 echo_command (text, from_tty) 3051 char *text; 3052 int from_tty; 3053 { 3054 char *p = text; 3055 register int c; 3056 3057 if (text) 3058 while ((c = *p++) != '\0') 3059 { 3060 if (c == '\\') 3061 { 3062 /* \ at end of argument is used after spaces 3063 so they won't be lost. */ 3064 if (*p == 0) 3065 return; 3066 3067 c = parse_escape (&p); 3068 if (c >= 0) 3069 printf_filtered ("%c", c); 3070 } 3071 else 3072 printf_filtered ("%c", c); 3073 } 3074 3075 /* Force this output to appear now. */ 3076 wrap_here (""); 3077 gdb_flush (gdb_stdout); 3078 } 3079 3080 /* ARGSUSED */ 3081 static void 3082 dont_repeat_command (ignored, from_tty) 3083 char *ignored; 3084 int from_tty; 3085 { 3086 *line = 0; /* Can't call dont_repeat here because we're not 3087 necessarily reading from stdin. */ 3088 } 3089 3090 #ifdef TARGET_BYTE_ORDER_SELECTABLE 3091 3092 /* Functions to manipulate the endianness of the target. */ 3093 3094 #ifndef TARGET_BYTE_ORDER_DEFAULT 3095 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN 3096 #endif 3097 3098 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT; 3099 3100 static int target_byte_order_auto = 1; 3101 3102 /* Called if the user enters ``set endian'' without an argument. */ 3103 static void 3104 set_endian (args, from_tty) 3105 char *args; 3106 int from_tty; 3107 { 3108 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n"); 3109 show_endian (args, from_tty); 3110 } 3111 3112 /* Called by ``set endian big''. */ 3113 static void 3114 set_endian_big (args, from_tty) 3115 char *args; 3116 int from_tty; 3117 { 3118 target_byte_order = BIG_ENDIAN; 3119 target_byte_order_auto = 0; 3120 } 3121 3122 /* Called by ``set endian little''. */ 3123 static void 3124 set_endian_little (args, from_tty) 3125 char *args; 3126 int from_tty; 3127 { 3128 target_byte_order = LITTLE_ENDIAN; 3129 target_byte_order_auto = 0; 3130 } 3131 3132 /* Called by ``set endian auto''. */ 3133 static void 3134 set_endian_auto (args, from_tty) 3135 char *args; 3136 int from_tty; 3137 { 3138 target_byte_order_auto = 1; 3139 } 3140 3141 /* Called by ``show endian''. */ 3142 static void 3143 show_endian (args, from_tty) 3144 char *args; 3145 int from_tty; 3146 { 3147 const char *msg = 3148 (target_byte_order_auto 3149 ? "The target endianness is set automatically (currently %s endian)\n" 3150 : "The target is assumed to be %s endian\n"); 3151 printf_unfiltered ((char *) msg, TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"); 3152 } 3153 3154 #endif /* defined (TARGET_BYTE_ORDER_SELECTABLE) */ 3155 3156 /* Set the endianness from a BFD. */ 3157 void 3158 set_endian_from_file (abfd) 3159 bfd *abfd; 3160 { 3161 #ifdef TARGET_BYTE_ORDER_SELECTABLE 3162 int want; 3163 3164 if (bfd_big_endian (abfd)) 3165 want = BIG_ENDIAN; 3166 else 3167 want = LITTLE_ENDIAN; 3168 if (target_byte_order_auto) 3169 target_byte_order = want; 3170 else if (target_byte_order != want) 3171 warning ("%s endian file does not match %s endian target.", 3172 want == BIG_ENDIAN ? "big" : "little", 3173 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"); 3174 3175 #else /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */ 3176 3177 if (bfd_big_endian (abfd) 3178 ? TARGET_BYTE_ORDER != BIG_ENDIAN 3179 : TARGET_BYTE_ORDER == BIG_ENDIAN) 3180 warning ("%s endian file does not match %s endian target.", 3181 bfd_big_endian (abfd) ? "big" : "little", 3182 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"); 3183 3184 #endif /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */ 3185 } 3186 3187 /* Functions to manipulate command line editing control variables. */ 3188 3189 /* Number of commands to print in each call to show_commands. */ 3190 #define Hist_print 10 3191 static void 3192 show_commands (args, from_tty) 3193 char *args; 3194 int from_tty; 3195 { 3196 /* Index for history commands. Relative to history_base. */ 3197 int offset; 3198 3199 /* Number of the history entry which we are planning to display next. 3200 Relative to history_base. */ 3201 static int num = 0; 3202 3203 /* The first command in the history which doesn't exist (i.e. one more 3204 than the number of the last command). Relative to history_base. */ 3205 int hist_len; 3206 3207 extern HIST_ENTRY *history_get PARAMS ((int)); 3208 3209 /* Print out some of the commands from the command history. */ 3210 /* First determine the length of the history list. */ 3211 hist_len = history_size; 3212 for (offset = 0; offset < history_size; offset++) 3213 { 3214 if (!history_get (history_base + offset)) 3215 { 3216 hist_len = offset; 3217 break; 3218 } 3219 } 3220 3221 if (args) 3222 { 3223 if (args[0] == '+' && args[1] == '\0') 3224 /* "info editing +" should print from the stored position. */ 3225 ; 3226 else 3227 /* "info editing <exp>" should print around command number <exp>. */ 3228 num = (parse_and_eval_address (args) - history_base) - Hist_print / 2; 3229 } 3230 /* "show commands" means print the last Hist_print commands. */ 3231 else 3232 { 3233 num = hist_len - Hist_print; 3234 } 3235 3236 if (num < 0) 3237 num = 0; 3238 3239 /* If there are at least Hist_print commands, we want to display the last 3240 Hist_print rather than, say, the last 6. */ 3241 if (hist_len - num < Hist_print) 3242 { 3243 num = hist_len - Hist_print; 3244 if (num < 0) 3245 num = 0; 3246 } 3247 3248 for (offset = num; offset < num + Hist_print && offset < hist_len; offset++) 3249 { 3250 printf_filtered ("%5d %s\n", history_base + offset, 3251 (history_get (history_base + offset))->line); 3252 } 3253 3254 /* The next command we want to display is the next one that we haven't 3255 displayed yet. */ 3256 num += Hist_print; 3257 3258 /* If the user repeats this command with return, it should do what 3259 "show commands +" does. This is unnecessary if arg is null, 3260 because "show commands +" is not useful after "show commands". */ 3261 if (from_tty && args) 3262 { 3263 args[0] = '+'; 3264 args[1] = '\0'; 3265 } 3266 } 3267 3268 /* Called by do_setshow_command. */ 3269 /* ARGSUSED */ 3270 static void 3271 set_history_size_command (args, from_tty, c) 3272 char *args; 3273 int from_tty; 3274 struct cmd_list_element *c; 3275 { 3276 if (history_size == INT_MAX) 3277 unstifle_history (); 3278 else if (history_size >= 0) 3279 stifle_history (history_size); 3280 else 3281 { 3282 history_size = INT_MAX; 3283 error ("History size must be non-negative"); 3284 } 3285 } 3286 3287 /* ARGSUSED */ 3288 static void 3289 set_history (args, from_tty) 3290 char *args; 3291 int from_tty; 3292 { 3293 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n"); 3294 help_list (sethistlist, "set history ", -1, gdb_stdout); 3295 } 3296 3297 /* ARGSUSED */ 3298 static void 3299 show_history (args, from_tty) 3300 char *args; 3301 int from_tty; 3302 { 3303 cmd_show_list (showhistlist, from_tty, ""); 3304 } 3305 3306 int info_verbose = 0; /* Default verbose msgs off */ 3307 3308 /* Called by do_setshow_command. An elaborate joke. */ 3309 /* ARGSUSED */ 3310 static void 3311 set_verbose (args, from_tty, c) 3312 char *args; 3313 int from_tty; 3314 struct cmd_list_element *c; 3315 { 3316 char *cmdname = "verbose"; 3317 struct cmd_list_element *showcmd; 3318 3319 showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1); 3320 3321 if (info_verbose) 3322 { 3323 c->doc = "Set verbose printing of informational messages."; 3324 showcmd->doc = "Show verbose printing of informational messages."; 3325 } 3326 else 3327 { 3328 c->doc = "Set verbosity."; 3329 showcmd->doc = "Show verbosity."; 3330 } 3331 } 3332 3333 static void 3334 float_handler (signo) 3335 int signo; 3336 { 3337 /* This message is based on ANSI C, section 4.7. Note that integer 3338 divide by zero causes this, so "float" is a misnomer. */ 3339 signal (SIGFPE, float_handler); 3340 error ("Erroneous arithmetic operation."); 3341 } 3342 3343 3344 static void 3345 init_cmd_lists () 3346 { 3347 cmdlist = NULL; 3348 infolist = NULL; 3349 enablelist = NULL; 3350 disablelist = NULL; 3351 deletelist = NULL; 3352 enablebreaklist = NULL; 3353 setlist = NULL; 3354 unsetlist = NULL; 3355 showlist = NULL; 3356 #ifdef TARGET_BYTE_ORDER_SELECTABLE 3357 endianlist = NULL; 3358 #endif 3359 sethistlist = NULL; 3360 showhistlist = NULL; 3361 unsethistlist = NULL; 3362 #if MAINTENANCE_CMDS 3363 maintenancelist = NULL; 3364 maintenanceinfolist = NULL; 3365 maintenanceprintlist = NULL; 3366 #endif 3367 setprintlist = NULL; 3368 showprintlist = NULL; 3369 setchecklist = NULL; 3370 showchecklist = NULL; 3371 } 3372 3373 /* Init the history buffer. Note that we are called after the init file(s) 3374 * have been read so that the user can change the history file via his 3375 * .gdbinit file (for instance). The GDBHISTFILE environment variable 3376 * overrides all of this. 3377 */ 3378 3379 void 3380 init_history() 3381 { 3382 char *tmpenv; 3383 3384 tmpenv = getenv ("HISTSIZE"); 3385 if (tmpenv) 3386 history_size = atoi (tmpenv); 3387 else if (!history_size) 3388 history_size = 256; 3389 3390 stifle_history (history_size); 3391 3392 tmpenv = getenv ("GDBHISTFILE"); 3393 if (tmpenv) 3394 history_filename = savestring (tmpenv, strlen(tmpenv)); 3395 else if (!history_filename) { 3396 /* We include the current directory so that if the user changes 3397 directories the file written will be the same as the one 3398 that was read. */ 3399 history_filename = concat (current_directory, "/.gdb_history", NULL); 3400 } 3401 read_history (history_filename); 3402 } 3403 3404 static void 3405 init_main () 3406 { 3407 struct cmd_list_element *c; 3408 3409 #ifdef TARGET_BYTE_ORDER_SELECTABLE 3410 3411 add_prefix_cmd ("endian", class_support, set_endian, 3412 "Set endianness of target.", 3413 &endianlist, "set endian ", 0, &setlist); 3414 add_cmd ("big", class_support, set_endian_big, 3415 "Set target as being big endian.", &endianlist); 3416 add_cmd ("little", class_support, set_endian_little, 3417 "Set target as being little endian.", &endianlist); 3418 add_cmd ("auto", class_support, set_endian_auto, 3419 "Select target endianness automatically.", &endianlist); 3420 add_cmd ("endian", class_support, show_endian, 3421 "Show endianness of target.", &showlist); 3422 3423 #endif /* defined (TARGET_BYTE_ORDER_SELECTABLE) */ 3424 3425 #ifdef DEFAULT_PROMPT 3426 prompt = savestring (DEFAULT_PROMPT, strlen(DEFAULT_PROMPT)); 3427 #else 3428 prompt = savestring ("(gdb) ", 6); 3429 #endif 3430 3431 /* Set the important stuff up for command editing. */ 3432 command_editing_p = 1; 3433 history_expansion_p = 0; 3434 write_history_p = 0; 3435 3436 /* Setup important stuff for command line editing. */ 3437 rl_completion_entry_function = (int (*)()) readline_line_completion_function; 3438 rl_completer_word_break_characters = gdb_completer_word_break_characters; 3439 rl_completer_quote_characters = gdb_completer_quote_characters; 3440 rl_readline_name = "gdb"; 3441 3442 /* Define the classes of commands. 3443 They will appear in the help list in the reverse of this order. */ 3444 3445 add_cmd ("internals", class_maintenance, NO_FUNCTION, 3446 "Maintenance commands.\n\ 3447 Some gdb commands are provided just for use by gdb maintainers.\n\ 3448 These commands are subject to frequent change, and may not be as\n\ 3449 well documented as user commands.", 3450 &cmdlist); 3451 add_cmd ("obscure", class_obscure, NO_FUNCTION, "Obscure features.", &cmdlist); 3452 add_cmd ("aliases", class_alias, NO_FUNCTION, "Aliases of other commands.", &cmdlist); 3453 add_cmd ("user-defined", class_user, NO_FUNCTION, "User-defined commands.\n\ 3454 The commands in this class are those defined by the user.\n\ 3455 Use the \"define\" command to define a command.", &cmdlist); 3456 add_cmd ("support", class_support, NO_FUNCTION, "Support facilities.", &cmdlist); 3457 add_cmd ("status", class_info, NO_FUNCTION, "Status inquiries.", &cmdlist); 3458 add_cmd ("files", class_files, NO_FUNCTION, "Specifying and examining files.", &cmdlist); 3459 add_cmd ("breakpoints", class_breakpoint, NO_FUNCTION, "Making program stop at certain points.", &cmdlist); 3460 add_cmd ("data", class_vars, NO_FUNCTION, "Examining data.", &cmdlist); 3461 add_cmd ("stack", class_stack, NO_FUNCTION, "Examining the stack.\n\ 3462 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\ 3463 counting from zero for the innermost (currently executing) frame.\n\n\ 3464 At any time gdb identifies one frame as the \"selected\" frame.\n\ 3465 Variable lookups are done with respect to the selected frame.\n\ 3466 When the program being debugged stops, gdb selects the innermost frame.\n\ 3467 The commands below can be used to select other frames by number or address.", 3468 &cmdlist); 3469 add_cmd ("running", class_run, NO_FUNCTION, "Running the program.", &cmdlist); 3470 3471 add_com ("pwd", class_files, pwd_command, 3472 "Print working directory. This is used for your program as well."); 3473 c = add_cmd ("cd", class_files, cd_command, 3474 "Set working directory to DIR for debugger and program being debugged.\n\ 3475 The change does not take effect for the program being debugged\n\ 3476 until the next time it is started.", &cmdlist); 3477 c->completer = filename_completer; 3478 3479 add_show_from_set 3480 (add_set_cmd ("prompt", class_support, var_string, (char *)&prompt, 3481 "Set gdb's prompt", 3482 &setlist), 3483 &showlist); 3484 3485 add_com ("echo", class_support, echo_command, 3486 "Print a constant string. Give string as argument.\n\ 3487 C escape sequences may be used in the argument.\n\ 3488 No newline is added at the end of the argument;\n\ 3489 use \"\\n\" if you want a newline to be printed.\n\ 3490 Since leading and trailing whitespace are ignored in command arguments,\n\ 3491 if you want to print some you must use \"\\\" before leading whitespace\n\ 3492 to be printed or after trailing whitespace."); 3493 add_com ("document", class_support, document_command, 3494 "Document a user-defined command.\n\ 3495 Give command name as argument. Give documentation on following lines.\n\ 3496 End with a line of just \"end\"."); 3497 add_com ("define", class_support, define_command, 3498 "Define a new command name. Command name is argument.\n\ 3499 Definition appears on following lines, one command per line.\n\ 3500 End with a line of just \"end\".\n\ 3501 Use the \"document\" command to give documentation for the new command.\n\ 3502 Commands defined in this way may have up to ten arguments."); 3503 3504 #ifdef __STDC__ 3505 c = add_cmd ("source", class_support, source_command, 3506 "Read commands from a file named FILE.\n\ 3507 Note that the file \"" GDBINIT_FILENAME "\" is read automatically in this way\n\ 3508 when gdb is started.", &cmdlist); 3509 #else 3510 /* Punt file name, we can't help it easily. */ 3511 c = add_cmd ("source", class_support, source_command, 3512 "Read commands from a file named FILE.\n\ 3513 Note that the file \".gdbinit\" is read automatically in this way\n\ 3514 when gdb is started.", &cmdlist); 3515 #endif 3516 c->completer = filename_completer; 3517 3518 add_com ("quit", class_support, quit_command, "Exit gdb."); 3519 add_com ("help", class_support, help_command, "Print list of commands."); 3520 add_com_alias ("q", "quit", class_support, 1); 3521 add_com_alias ("h", "help", class_support, 1); 3522 3523 add_com ("dont-repeat", class_support, dont_repeat_command, "Don't repeat this command.\n\ 3524 Primarily used inside of user-defined commands that should not be repeated when\n\ 3525 hitting return."); 3526 3527 c = add_set_cmd ("verbose", class_support, var_boolean, (char *)&info_verbose, 3528 "Set ", 3529 &setlist), 3530 add_show_from_set (c, &showlist); 3531 c->function.sfunc = set_verbose; 3532 set_verbose (NULL, 0, c); 3533 3534 add_show_from_set 3535 (add_set_cmd ("editing", class_support, var_boolean, (char *)&command_editing_p, 3536 "Set editing of command lines as they are typed.\n\ 3537 Use \"on\" to enable to enable the editing, and \"off\" to disable it.\n\ 3538 Without an argument, command line editing is enabled. To edit, use\n\ 3539 EMACS-like or VI-like commands like control-P or ESC.", &setlist), 3540 &showlist); 3541 3542 add_prefix_cmd ("history", class_support, set_history, 3543 "Generic command for setting command history parameters.", 3544 &sethistlist, "set history ", 0, &setlist); 3545 add_prefix_cmd ("history", class_support, show_history, 3546 "Generic command for showing command history parameters.", 3547 &showhistlist, "show history ", 0, &showlist); 3548 3549 add_show_from_set 3550 (add_set_cmd ("expansion", no_class, var_boolean, (char *)&history_expansion_p, 3551 "Set history expansion on command input.\n\ 3552 Without an argument, history expansion is enabled.", &sethistlist), 3553 &showhistlist); 3554 3555 add_show_from_set 3556 (add_set_cmd ("save", no_class, var_boolean, (char *)&write_history_p, 3557 "Set saving of the history record on exit.\n\ 3558 Use \"on\" to enable to enable the saving, and \"off\" to disable it.\n\ 3559 Without an argument, saving is enabled.", &sethistlist), 3560 &showhistlist); 3561 3562 c = add_set_cmd ("size", no_class, var_integer, (char *)&history_size, 3563 "Set the size of the command history, \n\ 3564 ie. the number of previous commands to keep a record of.", &sethistlist); 3565 add_show_from_set (c, &showhistlist); 3566 c->function.sfunc = set_history_size_command; 3567 3568 add_show_from_set 3569 (add_set_cmd ("filename", no_class, var_filename, (char *)&history_filename, 3570 "Set the filename in which to record the command history\n\ 3571 (the list of previous commands of which a record is kept).", &sethistlist), 3572 &showhistlist); 3573 3574 add_show_from_set 3575 (add_set_cmd ("confirm", class_support, var_boolean, 3576 (char *)&caution, 3577 "Set whether to confirm potentially dangerous operations.", 3578 &setlist), 3579 &showlist); 3580 3581 add_prefix_cmd ("info", class_info, info_command, 3582 "Generic command for showing things about the program being debugged.", 3583 &infolist, "info ", 0, &cmdlist); 3584 add_com_alias ("i", "info", class_info, 1); 3585 3586 add_com ("complete", class_obscure, complete_command, 3587 "List the completions for the rest of the line as a command."); 3588 3589 add_prefix_cmd ("show", class_info, show_command, 3590 "Generic command for showing things about the debugger.", 3591 &showlist, "show ", 0, &cmdlist); 3592 /* Another way to get at the same thing. */ 3593 add_info ("set", show_command, "Show all GDB settings."); 3594 3595 add_cmd ("commands", no_class, show_commands, 3596 "Show the history of commands you typed.\n\ 3597 You can supply a command number to start with, or a `+' to start after\n\ 3598 the previous command number shown.", 3599 &showlist); 3600 3601 add_cmd ("version", no_class, show_version, 3602 "Show what version of GDB this is.", &showlist); 3603 3604 add_com ("while", class_support, while_command, 3605 "Execute nested commands WHILE the conditional expression is non zero.\n\ 3606 The conditional expression must follow the word `while' and must in turn be\n\ 3607 followed by a new line. The nested commands must be entered one per line,\n\ 3608 and should be terminated by the word `end'."); 3609 3610 add_com ("if", class_support, if_command, 3611 "Execute nested commands once IF the conditional expression is non zero.\n\ 3612 The conditional expression must follow the word `if' and must in turn be\n\ 3613 followed by a new line. The nested commands must be entered one per line,\n\ 3614 and should be terminated by the word 'else' or `end'. If an else clause\n\ 3615 is used, the same rules apply to its nested commands as to the first ones."); 3616 3617 /* If target is open when baud changes, it doesn't take effect until the 3618 next open (I think, not sure). */ 3619 add_show_from_set (add_set_cmd ("remotebaud", no_class, 3620 var_zinteger, (char *)&baud_rate, 3621 "Set baud rate for remote serial I/O.\n\ 3622 This value is used to set the speed of the serial port when debugging\n\ 3623 using remote targets.", &setlist), 3624 &showlist); 3625 3626 add_show_from_set ( 3627 add_set_cmd ("remotedebug", no_class, var_zinteger, (char *)&remote_debug, 3628 "Set debugging of remote protocol.\n\ 3629 When enabled, each packet sent or received with the remote target\n\ 3630 is displayed.", &setlist), 3631 &showlist); 3632 3633 add_show_from_set ( 3634 add_set_cmd ("remotetimeout", no_class, var_integer, (char *)&remote_timeout, 3635 "Set timeout limit to wait for target to respond.\n\ 3636 This value is used to set the time limit for gdb to wait for a response\n\ 3637 from he target.", &setlist), 3638 &showlist); 3639 3640 c = add_set_cmd ("annotate", class_obscure, var_zinteger, 3641 (char *)&annotation_level, "Set annotation_level.\n\ 3642 0 == normal; 1 == fullname (for use when running under emacs)\n\ 3643 2 == output annotated suitably for use by programs that control GDB.", 3644 &setlist); 3645 c = add_show_from_set (c, &showlist); 3646 } 3647