1 /* GDB CLI command scripting. 2 3 Copyright (c) 1986-2002, 2004-2012 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "value.h" 22 #include "language.h" /* For value_true */ 23 #include <ctype.h> 24 25 #include "ui-out.h" 26 #include "gdb_string.h" 27 #include "exceptions.h" 28 #include "top.h" 29 #include "breakpoint.h" 30 #include "cli/cli-cmds.h" 31 #include "cli/cli-decode.h" 32 #include "cli/cli-script.h" 33 #include "gdb_assert.h" 34 35 #include "python/python.h" 36 #include "interps.h" 37 38 /* Prototypes for local functions. */ 39 40 static enum command_control_type 41 recurse_read_control_structure (char * (*read_next_line_func) (void), 42 struct command_line *current_cmd, 43 void (*validator)(char *, void *), 44 void *closure); 45 46 static char *insert_args (char *line); 47 48 static struct cleanup * setup_user_args (char *p); 49 50 static char *read_next_line (void); 51 52 /* Level of control structure when reading. */ 53 static int control_level; 54 55 /* Level of control structure when executing. */ 56 static int command_nest_depth = 1; 57 58 /* This is to prevent certain commands being printed twice. */ 59 static int suppress_next_print_command_trace = 0; 60 61 /* Structure for arguments to user defined functions. */ 62 #define MAXUSERARGS 10 63 struct user_args 64 { 65 struct user_args *next; 66 /* It is necessary to store a malloced copy of the command line to 67 ensure that the arguments are not overwritten before they are 68 used. */ 69 char *command; 70 struct 71 { 72 char *arg; 73 int len; 74 } 75 a[MAXUSERARGS]; 76 int count; 77 } 78 *user_args; 79 80 81 /* Allocate, initialize a new command line structure for one of the 82 control commands (if/while). */ 83 84 static struct command_line * 85 build_command_line (enum command_control_type type, char *args) 86 { 87 struct command_line *cmd; 88 89 if (args == NULL && (type == if_control || type == while_control)) 90 error (_("if/while commands require arguments.")); 91 gdb_assert (args != NULL); 92 93 cmd = (struct command_line *) xmalloc (sizeof (struct command_line)); 94 cmd->next = NULL; 95 cmd->control_type = type; 96 97 cmd->body_count = 1; 98 cmd->body_list 99 = (struct command_line **) xmalloc (sizeof (struct command_line *) 100 * cmd->body_count); 101 memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count); 102 cmd->line = xstrdup (args); 103 104 return cmd; 105 } 106 107 /* Build and return a new command structure for the control commands 108 such as "if" and "while". */ 109 110 struct command_line * 111 get_command_line (enum command_control_type type, char *arg) 112 { 113 struct command_line *cmd; 114 struct cleanup *old_chain = NULL; 115 116 /* Allocate and build a new command line structure. */ 117 cmd = build_command_line (type, arg); 118 119 old_chain = make_cleanup_free_command_lines (&cmd); 120 121 /* Read in the body of this command. */ 122 if (recurse_read_control_structure (read_next_line, cmd, 0, 0) 123 == invalid_control) 124 { 125 warning (_("Error reading in canned sequence of commands.")); 126 do_cleanups (old_chain); 127 return NULL; 128 } 129 130 discard_cleanups (old_chain); 131 return cmd; 132 } 133 134 /* Recursively print a command (including full control structures). */ 135 136 void 137 print_command_lines (struct ui_out *uiout, struct command_line *cmd, 138 unsigned int depth) 139 { 140 struct command_line *list; 141 142 list = cmd; 143 while (list) 144 { 145 if (depth) 146 ui_out_spaces (uiout, 2 * depth); 147 148 /* A simple command, print it and continue. */ 149 if (list->control_type == simple_control) 150 { 151 ui_out_field_string (uiout, NULL, list->line); 152 ui_out_text (uiout, "\n"); 153 list = list->next; 154 continue; 155 } 156 157 /* loop_continue to jump to the start of a while loop, print it 158 and continue. */ 159 if (list->control_type == continue_control) 160 { 161 ui_out_field_string (uiout, NULL, "loop_continue"); 162 ui_out_text (uiout, "\n"); 163 list = list->next; 164 continue; 165 } 166 167 /* loop_break to break out of a while loop, print it and 168 continue. */ 169 if (list->control_type == break_control) 170 { 171 ui_out_field_string (uiout, NULL, "loop_break"); 172 ui_out_text (uiout, "\n"); 173 list = list->next; 174 continue; 175 } 176 177 /* A while command. Recursively print its subcommands and 178 continue. */ 179 if (list->control_type == while_control 180 || list->control_type == while_stepping_control) 181 { 182 /* For while-stepping, the line includes the 'while-stepping' 183 token. See comment in process_next_line for explanation. 184 Here, take care not print 'while-stepping' twice. */ 185 if (list->control_type == while_control) 186 ui_out_field_fmt (uiout, NULL, "while %s", list->line); 187 else 188 ui_out_field_string (uiout, NULL, list->line); 189 ui_out_text (uiout, "\n"); 190 print_command_lines (uiout, *list->body_list, depth + 1); 191 if (depth) 192 ui_out_spaces (uiout, 2 * depth); 193 ui_out_field_string (uiout, NULL, "end"); 194 ui_out_text (uiout, "\n"); 195 list = list->next; 196 continue; 197 } 198 199 /* An if command. Recursively print both arms before 200 continueing. */ 201 if (list->control_type == if_control) 202 { 203 ui_out_field_fmt (uiout, NULL, "if %s", list->line); 204 ui_out_text (uiout, "\n"); 205 /* The true arm. */ 206 print_command_lines (uiout, list->body_list[0], depth + 1); 207 208 /* Show the false arm if it exists. */ 209 if (list->body_count == 2) 210 { 211 if (depth) 212 ui_out_spaces (uiout, 2 * depth); 213 ui_out_field_string (uiout, NULL, "else"); 214 ui_out_text (uiout, "\n"); 215 print_command_lines (uiout, list->body_list[1], depth + 1); 216 } 217 218 if (depth) 219 ui_out_spaces (uiout, 2 * depth); 220 ui_out_field_string (uiout, NULL, "end"); 221 ui_out_text (uiout, "\n"); 222 list = list->next; 223 continue; 224 } 225 226 /* A commands command. Print the breakpoint commands and 227 continue. */ 228 if (list->control_type == commands_control) 229 { 230 if (*(list->line)) 231 ui_out_field_fmt (uiout, NULL, "commands %s", list->line); 232 else 233 ui_out_field_string (uiout, NULL, "commands"); 234 ui_out_text (uiout, "\n"); 235 print_command_lines (uiout, *list->body_list, depth + 1); 236 if (depth) 237 ui_out_spaces (uiout, 2 * depth); 238 ui_out_field_string (uiout, NULL, "end"); 239 ui_out_text (uiout, "\n"); 240 list = list->next; 241 continue; 242 } 243 244 if (list->control_type == python_control) 245 { 246 ui_out_field_string (uiout, NULL, "python"); 247 ui_out_text (uiout, "\n"); 248 /* Don't indent python code at all. */ 249 print_command_lines (uiout, *list->body_list, 0); 250 if (depth) 251 ui_out_spaces (uiout, 2 * depth); 252 ui_out_field_string (uiout, NULL, "end"); 253 ui_out_text (uiout, "\n"); 254 list = list->next; 255 continue; 256 } 257 258 /* Ignore illegal command type and try next. */ 259 list = list->next; 260 } /* while (list) */ 261 } 262 263 /* Handle pre-post hooks. */ 264 265 static void 266 clear_hook_in_cleanup (void *data) 267 { 268 struct cmd_list_element *c = data; 269 270 c->hook_in = 0; /* Allow hook to work again once it is complete. */ 271 } 272 273 void 274 execute_cmd_pre_hook (struct cmd_list_element *c) 275 { 276 if ((c->hook_pre) && (!c->hook_in)) 277 { 278 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c); 279 c->hook_in = 1; /* Prevent recursive hooking. */ 280 execute_user_command (c->hook_pre, (char *) 0); 281 do_cleanups (cleanups); 282 } 283 } 284 285 void 286 execute_cmd_post_hook (struct cmd_list_element *c) 287 { 288 if ((c->hook_post) && (!c->hook_in)) 289 { 290 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c); 291 292 c->hook_in = 1; /* Prevent recursive hooking. */ 293 execute_user_command (c->hook_post, (char *) 0); 294 do_cleanups (cleanups); 295 } 296 } 297 298 /* Execute the command in CMD. */ 299 static void 300 do_restore_user_call_depth (void * call_depth) 301 { 302 int *depth = call_depth; 303 304 (*depth)--; 305 if ((*depth) == 0) 306 in_user_command = 0; 307 } 308 309 310 void 311 execute_user_command (struct cmd_list_element *c, char *args) 312 { 313 struct command_line *cmdlines; 314 struct cleanup *old_chain; 315 enum command_control_type ret; 316 static int user_call_depth = 0; 317 extern int max_user_call_depth; 318 319 cmdlines = c->user_commands; 320 if (cmdlines == 0) 321 /* Null command */ 322 return; 323 324 old_chain = setup_user_args (args); 325 326 if (++user_call_depth > max_user_call_depth) 327 error (_("Max user call depth exceeded -- command aborted.")); 328 329 make_cleanup (do_restore_user_call_depth, &user_call_depth); 330 331 /* Set the instream to 0, indicating execution of a 332 user-defined function. */ 333 make_cleanup (do_restore_instream_cleanup, instream); 334 instream = (FILE *) 0; 335 336 /* Also set the global in_user_command, so that NULL instream is 337 not confused with Insight. */ 338 in_user_command = 1; 339 340 make_cleanup_restore_integer (&interpreter_async); 341 interpreter_async = 0; 342 343 command_nest_depth++; 344 while (cmdlines) 345 { 346 ret = execute_control_command (cmdlines); 347 if (ret != simple_control && ret != break_control) 348 { 349 warning (_("Error executing canned sequence of commands.")); 350 break; 351 } 352 cmdlines = cmdlines->next; 353 } 354 command_nest_depth--; 355 do_cleanups (old_chain); 356 } 357 358 /* This function is called every time GDB prints a prompt. It ensures 359 that errors and the like do not confuse the command tracing. */ 360 361 void 362 reset_command_nest_depth (void) 363 { 364 command_nest_depth = 1; 365 366 /* Just in case. */ 367 suppress_next_print_command_trace = 0; 368 } 369 370 /* Print the command, prefixed with '+' to represent the call depth. 371 This is slightly complicated because this function may be called 372 from execute_command and execute_control_command. Unfortunately 373 execute_command also prints the top level control commands. 374 In these cases execute_command will call execute_control_command 375 via while_command or if_command. Inner levels of 'if' and 'while' 376 are dealt with directly. Therefore we can use these functions 377 to determine whether the command has been printed already or not. */ 378 void 379 print_command_trace (const char *cmd) 380 { 381 int i; 382 383 if (suppress_next_print_command_trace) 384 { 385 suppress_next_print_command_trace = 0; 386 return; 387 } 388 389 if (!source_verbose && !trace_commands) 390 return; 391 392 for (i=0; i < command_nest_depth; i++) 393 printf_filtered ("+"); 394 395 printf_filtered ("%s\n", cmd); 396 } 397 398 enum command_control_type 399 execute_control_command (struct command_line *cmd) 400 { 401 struct expression *expr; 402 struct command_line *current; 403 struct cleanup *old_chain = make_cleanup (null_cleanup, 0); 404 struct value *val; 405 struct value *val_mark; 406 int loop; 407 enum command_control_type ret; 408 char *new_line; 409 410 /* Start by assuming failure, if a problem is detected, the code 411 below will simply "break" out of the switch. */ 412 ret = invalid_control; 413 414 switch (cmd->control_type) 415 { 416 case simple_control: 417 /* A simple command, execute it and return. */ 418 new_line = insert_args (cmd->line); 419 if (!new_line) 420 break; 421 make_cleanup (free_current_contents, &new_line); 422 execute_command (new_line, 0); 423 ret = cmd->control_type; 424 break; 425 426 case continue_control: 427 print_command_trace ("loop_continue"); 428 429 /* Return for "continue", and "break" so we can either 430 continue the loop at the top, or break out. */ 431 ret = cmd->control_type; 432 break; 433 434 case break_control: 435 print_command_trace ("loop_break"); 436 437 /* Return for "continue", and "break" so we can either 438 continue the loop at the top, or break out. */ 439 ret = cmd->control_type; 440 break; 441 442 case while_control: 443 { 444 char *buffer = alloca (strlen (cmd->line) + 7); 445 446 sprintf (buffer, "while %s", cmd->line); 447 print_command_trace (buffer); 448 449 /* Parse the loop control expression for the while statement. */ 450 new_line = insert_args (cmd->line); 451 if (!new_line) 452 break; 453 make_cleanup (free_current_contents, &new_line); 454 expr = parse_expression (new_line); 455 make_cleanup (free_current_contents, &expr); 456 457 ret = simple_control; 458 loop = 1; 459 460 /* Keep iterating so long as the expression is true. */ 461 while (loop == 1) 462 { 463 int cond_result; 464 465 QUIT; 466 467 /* Evaluate the expression. */ 468 val_mark = value_mark (); 469 val = evaluate_expression (expr); 470 cond_result = value_true (val); 471 value_free_to_mark (val_mark); 472 473 /* If the value is false, then break out of the loop. */ 474 if (!cond_result) 475 break; 476 477 /* Execute the body of the while statement. */ 478 current = *cmd->body_list; 479 while (current) 480 { 481 command_nest_depth++; 482 ret = execute_control_command (current); 483 command_nest_depth--; 484 485 /* If we got an error, or a "break" command, then stop 486 looping. */ 487 if (ret == invalid_control || ret == break_control) 488 { 489 loop = 0; 490 break; 491 } 492 493 /* If we got a "continue" command, then restart the loop 494 at this point. */ 495 if (ret == continue_control) 496 break; 497 498 /* Get the next statement. */ 499 current = current->next; 500 } 501 } 502 503 /* Reset RET so that we don't recurse the break all the way down. */ 504 if (ret == break_control) 505 ret = simple_control; 506 507 break; 508 } 509 510 case if_control: 511 { 512 char *buffer = alloca (strlen (cmd->line) + 4); 513 514 sprintf (buffer, "if %s", cmd->line); 515 print_command_trace (buffer); 516 517 new_line = insert_args (cmd->line); 518 if (!new_line) 519 break; 520 make_cleanup (free_current_contents, &new_line); 521 /* Parse the conditional for the if statement. */ 522 expr = parse_expression (new_line); 523 make_cleanup (free_current_contents, &expr); 524 525 current = NULL; 526 ret = simple_control; 527 528 /* Evaluate the conditional. */ 529 val_mark = value_mark (); 530 val = evaluate_expression (expr); 531 532 /* Choose which arm to take commands from based on the value 533 of the conditional expression. */ 534 if (value_true (val)) 535 current = *cmd->body_list; 536 else if (cmd->body_count == 2) 537 current = *(cmd->body_list + 1); 538 value_free_to_mark (val_mark); 539 540 /* Execute commands in the given arm. */ 541 while (current) 542 { 543 command_nest_depth++; 544 ret = execute_control_command (current); 545 command_nest_depth--; 546 547 /* If we got an error, get out. */ 548 if (ret != simple_control) 549 break; 550 551 /* Get the next statement in the body. */ 552 current = current->next; 553 } 554 555 break; 556 } 557 case commands_control: 558 { 559 /* Breakpoint commands list, record the commands in the 560 breakpoint's command list and return. */ 561 new_line = insert_args (cmd->line); 562 if (!new_line) 563 break; 564 make_cleanup (free_current_contents, &new_line); 565 ret = commands_from_control_command (new_line, cmd); 566 break; 567 } 568 case python_control: 569 { 570 eval_python_from_control_command (cmd); 571 ret = simple_control; 572 break; 573 } 574 575 default: 576 warning (_("Invalid control type in canned commands structure.")); 577 break; 578 } 579 580 do_cleanups (old_chain); 581 582 return ret; 583 } 584 585 /* Like execute_control_command, but first set 586 suppress_next_print_command_trace. */ 587 588 enum command_control_type 589 execute_control_command_untraced (struct command_line *cmd) 590 { 591 suppress_next_print_command_trace = 1; 592 return execute_control_command (cmd); 593 } 594 595 596 /* "while" command support. Executes a body of statements while the 597 loop condition is nonzero. */ 598 599 void 600 while_command (char *arg, int from_tty) 601 { 602 struct command_line *command = NULL; 603 struct cleanup *old_chain; 604 605 control_level = 1; 606 command = get_command_line (while_control, arg); 607 608 if (command == NULL) 609 return; 610 611 old_chain = make_cleanup_restore_integer (&interpreter_async); 612 interpreter_async = 0; 613 614 execute_control_command_untraced (command); 615 free_command_lines (&command); 616 617 do_cleanups (old_chain); 618 } 619 620 /* "if" command support. Execute either the true or false arm depending 621 on the value of the if conditional. */ 622 623 void 624 if_command (char *arg, int from_tty) 625 { 626 struct command_line *command = NULL; 627 struct cleanup *old_chain; 628 629 control_level = 1; 630 command = get_command_line (if_control, arg); 631 632 if (command == NULL) 633 return; 634 635 old_chain = make_cleanup_restore_integer (&interpreter_async); 636 interpreter_async = 0; 637 638 execute_control_command_untraced (command); 639 free_command_lines (&command); 640 641 do_cleanups (old_chain); 642 } 643 644 /* Cleanup */ 645 static void 646 arg_cleanup (void *ignore) 647 { 648 struct user_args *oargs = user_args; 649 650 if (!user_args) 651 internal_error (__FILE__, __LINE__, 652 _("arg_cleanup called with no user args.\n")); 653 654 user_args = user_args->next; 655 xfree (oargs->command); 656 xfree (oargs); 657 } 658 659 /* Bind the incomming arguments for a user defined command to 660 $arg0, $arg1 ... $argMAXUSERARGS. */ 661 662 static struct cleanup * 663 setup_user_args (char *p) 664 { 665 struct user_args *args; 666 struct cleanup *old_chain; 667 unsigned int arg_count = 0; 668 669 args = (struct user_args *) xmalloc (sizeof (struct user_args)); 670 memset (args, 0, sizeof (struct user_args)); 671 672 args->next = user_args; 673 user_args = args; 674 675 old_chain = make_cleanup (arg_cleanup, 0/*ignored*/); 676 677 if (p == NULL) 678 return old_chain; 679 680 user_args->command = p = xstrdup (p); 681 682 while (*p) 683 { 684 char *start_arg; 685 int squote = 0; 686 int dquote = 0; 687 int bsquote = 0; 688 689 if (arg_count >= MAXUSERARGS) 690 { 691 error (_("user defined function may only have %d arguments."), 692 MAXUSERARGS); 693 return old_chain; 694 } 695 696 /* Strip whitespace. */ 697 while (*p == ' ' || *p == '\t') 698 p++; 699 700 /* P now points to an argument. */ 701 start_arg = p; 702 user_args->a[arg_count].arg = p; 703 704 /* Get to the end of this argument. */ 705 while (*p) 706 { 707 if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote) 708 break; 709 else 710 { 711 if (bsquote) 712 bsquote = 0; 713 else if (*p == '\\') 714 bsquote = 1; 715 else if (squote) 716 { 717 if (*p == '\'') 718 squote = 0; 719 } 720 else if (dquote) 721 { 722 if (*p == '"') 723 dquote = 0; 724 } 725 else 726 { 727 if (*p == '\'') 728 squote = 1; 729 else if (*p == '"') 730 dquote = 1; 731 } 732 p++; 733 } 734 } 735 736 user_args->a[arg_count].len = p - start_arg; 737 arg_count++; 738 user_args->count++; 739 } 740 return old_chain; 741 } 742 743 /* Given character string P, return a point to the first argument 744 ($arg), or NULL if P contains no arguments. */ 745 746 static char * 747 locate_arg (char *p) 748 { 749 while ((p = strchr (p, '$'))) 750 { 751 if (strncmp (p, "$arg", 4) == 0 752 && (isdigit (p[4]) || p[4] == 'c')) 753 return p; 754 p++; 755 } 756 return NULL; 757 } 758 759 /* Insert the user defined arguments stored in user_arg into the $arg 760 arguments found in line, with the updated copy being placed into 761 nline. */ 762 763 static char * 764 insert_args (char *line) 765 { 766 char *p, *save_line, *new_line; 767 unsigned len, i; 768 769 /* If we are not in a user-defined function, treat $argc, $arg0, et 770 cetera as normal convenience variables. */ 771 if (user_args == NULL) 772 return xstrdup (line); 773 774 /* First we need to know how much memory to allocate for the new 775 line. */ 776 save_line = line; 777 len = 0; 778 while ((p = locate_arg (line))) 779 { 780 len += p - line; 781 i = p[4] - '0'; 782 783 if (p[4] == 'c') 784 { 785 /* $argc. Number will be <=10. */ 786 len += user_args->count == 10 ? 2 : 1; 787 } 788 else if (i >= user_args->count) 789 { 790 error (_("Missing argument %d in user function."), i); 791 return NULL; 792 } 793 else 794 { 795 len += user_args->a[i].len; 796 } 797 line = p + 5; 798 } 799 800 /* Don't forget the tail. */ 801 len += strlen (line); 802 803 /* Allocate space for the new line and fill it in. */ 804 new_line = (char *) xmalloc (len + 1); 805 if (new_line == NULL) 806 return NULL; 807 808 /* Restore pointer to beginning of old line. */ 809 line = save_line; 810 811 /* Save pointer to beginning of new line. */ 812 save_line = new_line; 813 814 while ((p = locate_arg (line))) 815 { 816 int i, len; 817 818 memcpy (new_line, line, p - line); 819 new_line += p - line; 820 821 if (p[4] == 'c') 822 { 823 gdb_assert (user_args->count >= 0 && user_args->count <= 10); 824 if (user_args->count == 10) 825 { 826 *(new_line++) = '1'; 827 *(new_line++) = '0'; 828 } 829 else 830 *(new_line++) = user_args->count + '0'; 831 } 832 else 833 { 834 i = p[4] - '0'; 835 len = user_args->a[i].len; 836 if (len) 837 { 838 memcpy (new_line, user_args->a[i].arg, len); 839 new_line += len; 840 } 841 } 842 line = p + 5; 843 } 844 /* Don't forget the tail. */ 845 strcpy (new_line, line); 846 847 /* Return a pointer to the beginning of the new line. */ 848 return save_line; 849 } 850 851 852 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH 853 code bodies. This is typically used when we encounter an "else" 854 clause for an "if" command. */ 855 856 static void 857 realloc_body_list (struct command_line *command, int new_length) 858 { 859 int n; 860 struct command_line **body_list; 861 862 n = command->body_count; 863 864 /* Nothing to do? */ 865 if (new_length <= n) 866 return; 867 868 body_list = (struct command_line **) 869 xmalloc (sizeof (struct command_line *) * new_length); 870 871 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n); 872 memset (body_list + n, 0, sizeof (struct command_line *) * (new_length - n)); 873 874 xfree (command->body_list); 875 command->body_list = body_list; 876 command->body_count = new_length; 877 } 878 879 /* Read next line from stdout. Passed to read_command_line_1 and 880 recurse_read_control_structure whenever we need to read commands 881 from stdout. */ 882 883 static char * 884 read_next_line (void) 885 { 886 char *prompt_ptr, control_prompt[256]; 887 int i = 0; 888 889 if (control_level >= 254) 890 error (_("Control nesting too deep!")); 891 892 /* Set a prompt based on the nesting of the control commands. */ 893 if (instream == stdin || (instream == 0 && deprecated_readline_hook != NULL)) 894 { 895 for (i = 0; i < control_level; i++) 896 control_prompt[i] = ' '; 897 control_prompt[i] = '>'; 898 control_prompt[i + 1] = '\0'; 899 prompt_ptr = (char *) &control_prompt[0]; 900 } 901 else 902 prompt_ptr = NULL; 903 904 return command_line_input (prompt_ptr, instream == stdin, "commands"); 905 } 906 907 /* Process one input line. If the command is an "end", return such an 908 indication to the caller. If PARSE_COMMANDS is true, strip leading 909 whitespace (trailing whitespace is always stripped) in the line, 910 attempt to recognize GDB control commands, and also return an 911 indication if the command is an "else" or a nop. 912 913 Otherwise, only "end" is recognized. */ 914 915 static enum misc_command_type 916 process_next_line (char *p, struct command_line **command, int parse_commands, 917 void (*validator)(char *, void *), void *closure) 918 { 919 char *p_end; 920 char *p_start; 921 int not_handled = 0; 922 923 /* Not sure what to do here. */ 924 if (p == NULL) 925 return end_command; 926 927 /* Strip trailing whitespace. */ 928 p_end = p + strlen (p); 929 while (p_end > p && (p_end[-1] == ' ' || p_end[-1] == '\t')) 930 p_end--; 931 932 p_start = p; 933 /* Strip leading whitespace. */ 934 while (p_start < p_end && (*p_start == ' ' || *p_start == '\t')) 935 p_start++; 936 937 /* 'end' is always recognized, regardless of parse_commands value. 938 We also permit whitespace before end and after. */ 939 if (p_end - p_start == 3 && !strncmp (p_start, "end", 3)) 940 return end_command; 941 942 if (parse_commands) 943 { 944 /* If commands are parsed, we skip initial spaces. Otherwise, 945 which is the case for Python commands and documentation 946 (see the 'document' command), spaces are preserved. */ 947 p = p_start; 948 949 /* Blanks and comments don't really do anything, but we need to 950 distinguish them from else, end and other commands which can 951 be executed. */ 952 if (p_end == p || p[0] == '#') 953 return nop_command; 954 955 /* Is the else clause of an if control structure? */ 956 if (p_end - p == 4 && !strncmp (p, "else", 4)) 957 return else_command; 958 959 /* Check for while, if, break, continue, etc and build a new 960 command line structure for them. */ 961 if ((p_end - p >= 14 && !strncmp (p, "while-stepping", 14)) 962 || (p_end - p >= 8 && !strncmp (p, "stepping", 8)) 963 || (p_end - p >= 2 && !strncmp (p, "ws", 2))) 964 { 965 /* Because validate_actionline and encode_action lookup 966 command's line as command, we need the line to 967 include 'while-stepping'. 968 969 For 'ws' alias, the command will have 'ws', not expanded 970 to 'while-stepping'. This is intentional -- we don't 971 really want frontend to send a command list with 'ws', 972 and next break-info returning command line with 973 'while-stepping'. This should work, but might cause the 974 breakpoint to be marked as changed while it's actually 975 not. */ 976 *command = build_command_line (while_stepping_control, p); 977 } 978 else if (p_end - p > 5 && !strncmp (p, "while", 5)) 979 { 980 char *first_arg; 981 982 first_arg = p + 5; 983 while (first_arg < p_end && isspace (*first_arg)) 984 first_arg++; 985 *command = build_command_line (while_control, first_arg); 986 } 987 else if (p_end - p > 2 && !strncmp (p, "if", 2)) 988 { 989 char *first_arg; 990 991 first_arg = p + 2; 992 while (first_arg < p_end && isspace (*first_arg)) 993 first_arg++; 994 *command = build_command_line (if_control, first_arg); 995 } 996 else if (p_end - p >= 8 && !strncmp (p, "commands", 8)) 997 { 998 char *first_arg; 999 1000 first_arg = p + 8; 1001 while (first_arg < p_end && isspace (*first_arg)) 1002 first_arg++; 1003 *command = build_command_line (commands_control, first_arg); 1004 } 1005 else if (p_end - p == 6 && !strncmp (p, "python", 6)) 1006 { 1007 /* Note that we ignore the inline "python command" form 1008 here. */ 1009 *command = build_command_line (python_control, ""); 1010 } 1011 else if (p_end - p == 10 && !strncmp (p, "loop_break", 10)) 1012 { 1013 *command = (struct command_line *) 1014 xmalloc (sizeof (struct command_line)); 1015 (*command)->next = NULL; 1016 (*command)->line = NULL; 1017 (*command)->control_type = break_control; 1018 (*command)->body_count = 0; 1019 (*command)->body_list = NULL; 1020 } 1021 else if (p_end - p == 13 && !strncmp (p, "loop_continue", 13)) 1022 { 1023 *command = (struct command_line *) 1024 xmalloc (sizeof (struct command_line)); 1025 (*command)->next = NULL; 1026 (*command)->line = NULL; 1027 (*command)->control_type = continue_control; 1028 (*command)->body_count = 0; 1029 (*command)->body_list = NULL; 1030 } 1031 else 1032 not_handled = 1; 1033 } 1034 1035 if (!parse_commands || not_handled) 1036 { 1037 /* A normal command. */ 1038 *command = (struct command_line *) 1039 xmalloc (sizeof (struct command_line)); 1040 (*command)->next = NULL; 1041 (*command)->line = savestring (p, p_end - p); 1042 (*command)->control_type = simple_control; 1043 (*command)->body_count = 0; 1044 (*command)->body_list = NULL; 1045 } 1046 1047 if (validator) 1048 { 1049 volatile struct gdb_exception ex; 1050 1051 TRY_CATCH (ex, RETURN_MASK_ALL) 1052 { 1053 validator ((*command)->line, closure); 1054 } 1055 if (ex.reason < 0) 1056 { 1057 xfree (*command); 1058 throw_exception (ex); 1059 } 1060 } 1061 1062 /* Nothing special. */ 1063 return ok_command; 1064 } 1065 1066 /* Recursively read in the control structures and create a 1067 command_line structure from them. Use read_next_line_func to 1068 obtain lines of the command. */ 1069 1070 static enum command_control_type 1071 recurse_read_control_structure (char * (*read_next_line_func) (void), 1072 struct command_line *current_cmd, 1073 void (*validator)(char *, void *), 1074 void *closure) 1075 { 1076 int current_body, i; 1077 enum misc_command_type val; 1078 enum command_control_type ret; 1079 struct command_line **body_ptr, *child_tail, *next; 1080 1081 child_tail = NULL; 1082 current_body = 1; 1083 1084 /* Sanity checks. */ 1085 if (current_cmd->control_type == simple_control) 1086 error (_("Recursed on a simple control type.")); 1087 1088 if (current_body > current_cmd->body_count) 1089 error (_("Allocated body is smaller than this command type needs.")); 1090 1091 /* Read lines from the input stream and build control structures. */ 1092 while (1) 1093 { 1094 dont_repeat (); 1095 1096 next = NULL; 1097 val = process_next_line (read_next_line_func (), &next, 1098 current_cmd->control_type != python_control, 1099 validator, closure); 1100 1101 /* Just skip blanks and comments. */ 1102 if (val == nop_command) 1103 continue; 1104 1105 if (val == end_command) 1106 { 1107 if (current_cmd->control_type == while_control 1108 || current_cmd->control_type == while_stepping_control 1109 || current_cmd->control_type == if_control 1110 || current_cmd->control_type == python_control 1111 || current_cmd->control_type == commands_control) 1112 { 1113 /* Success reading an entire canned sequence of commands. */ 1114 ret = simple_control; 1115 break; 1116 } 1117 else 1118 { 1119 ret = invalid_control; 1120 break; 1121 } 1122 } 1123 1124 /* Not the end of a control structure. */ 1125 if (val == else_command) 1126 { 1127 if (current_cmd->control_type == if_control 1128 && current_body == 1) 1129 { 1130 realloc_body_list (current_cmd, 2); 1131 current_body = 2; 1132 child_tail = NULL; 1133 continue; 1134 } 1135 else 1136 { 1137 ret = invalid_control; 1138 break; 1139 } 1140 } 1141 1142 if (child_tail) 1143 { 1144 child_tail->next = next; 1145 } 1146 else 1147 { 1148 body_ptr = current_cmd->body_list; 1149 for (i = 1; i < current_body; i++) 1150 body_ptr++; 1151 1152 *body_ptr = next; 1153 1154 } 1155 1156 child_tail = next; 1157 1158 /* If the latest line is another control structure, then recurse 1159 on it. */ 1160 if (next->control_type == while_control 1161 || next->control_type == while_stepping_control 1162 || next->control_type == if_control 1163 || next->control_type == python_control 1164 || next->control_type == commands_control) 1165 { 1166 control_level++; 1167 ret = recurse_read_control_structure (read_next_line_func, next, 1168 validator, closure); 1169 control_level--; 1170 1171 if (ret != simple_control) 1172 break; 1173 } 1174 } 1175 1176 dont_repeat (); 1177 1178 return ret; 1179 } 1180 1181 /* Read lines from the input stream and accumulate them in a chain of 1182 struct command_line's, which is then returned. For input from a 1183 terminal, the special command "end" is used to mark the end of the 1184 input, and is not included in the returned chain of commands. 1185 1186 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace 1187 is always stripped) in the line and attempt to recognize GDB control 1188 commands. Otherwise, only "end" is recognized. */ 1189 1190 #define END_MESSAGE "End with a line saying just \"end\"." 1191 1192 struct command_line * 1193 read_command_lines (char *prompt_arg, int from_tty, int parse_commands, 1194 void (*validator)(char *, void *), void *closure) 1195 { 1196 struct command_line *head; 1197 1198 if (from_tty && input_from_terminal_p ()) 1199 { 1200 if (deprecated_readline_begin_hook) 1201 { 1202 /* Note - intentional to merge messages with no newline. */ 1203 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg, 1204 END_MESSAGE); 1205 } 1206 else 1207 { 1208 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE); 1209 gdb_flush (gdb_stdout); 1210 } 1211 } 1212 1213 head = read_command_lines_1 (read_next_line, parse_commands, 1214 validator, closure); 1215 1216 if (deprecated_readline_end_hook && from_tty && input_from_terminal_p ()) 1217 { 1218 (*deprecated_readline_end_hook) (); 1219 } 1220 return (head); 1221 } 1222 1223 /* Act the same way as read_command_lines, except that each new line is 1224 obtained using READ_NEXT_LINE_FUNC. */ 1225 1226 struct command_line * 1227 read_command_lines_1 (char * (*read_next_line_func) (void), int parse_commands, 1228 void (*validator)(char *, void *), void *closure) 1229 { 1230 struct command_line *head, *tail, *next; 1231 struct cleanup *old_chain; 1232 enum command_control_type ret; 1233 enum misc_command_type val; 1234 1235 control_level = 0; 1236 head = tail = NULL; 1237 old_chain = NULL; 1238 1239 while (1) 1240 { 1241 dont_repeat (); 1242 val = process_next_line (read_next_line_func (), &next, parse_commands, 1243 validator, closure); 1244 1245 /* Ignore blank lines or comments. */ 1246 if (val == nop_command) 1247 continue; 1248 1249 if (val == end_command) 1250 { 1251 ret = simple_control; 1252 break; 1253 } 1254 1255 if (val != ok_command) 1256 { 1257 ret = invalid_control; 1258 break; 1259 } 1260 1261 if (next->control_type == while_control 1262 || next->control_type == if_control 1263 || next->control_type == python_control 1264 || next->control_type == commands_control 1265 || next->control_type == while_stepping_control) 1266 { 1267 control_level++; 1268 ret = recurse_read_control_structure (read_next_line_func, next, 1269 validator, closure); 1270 control_level--; 1271 1272 if (ret == invalid_control) 1273 break; 1274 } 1275 1276 if (tail) 1277 { 1278 tail->next = next; 1279 } 1280 else 1281 { 1282 head = next; 1283 old_chain = make_cleanup_free_command_lines (&head); 1284 } 1285 tail = next; 1286 } 1287 1288 dont_repeat (); 1289 1290 if (head) 1291 { 1292 if (ret != invalid_control) 1293 { 1294 discard_cleanups (old_chain); 1295 } 1296 else 1297 do_cleanups (old_chain); 1298 } 1299 1300 return head; 1301 } 1302 1303 /* Free a chain of struct command_line's. */ 1304 1305 void 1306 free_command_lines (struct command_line **lptr) 1307 { 1308 struct command_line *l = *lptr; 1309 struct command_line *next; 1310 struct command_line **blist; 1311 int i; 1312 1313 while (l) 1314 { 1315 if (l->body_count > 0) 1316 { 1317 blist = l->body_list; 1318 for (i = 0; i < l->body_count; i++, blist++) 1319 free_command_lines (blist); 1320 } 1321 next = l->next; 1322 xfree (l->line); 1323 xfree (l); 1324 l = next; 1325 } 1326 *lptr = NULL; 1327 } 1328 1329 static void 1330 do_free_command_lines_cleanup (void *arg) 1331 { 1332 free_command_lines (arg); 1333 } 1334 1335 struct cleanup * 1336 make_cleanup_free_command_lines (struct command_line **arg) 1337 { 1338 return make_cleanup (do_free_command_lines_cleanup, arg); 1339 } 1340 1341 struct command_line * 1342 copy_command_lines (struct command_line *cmds) 1343 { 1344 struct command_line *result = NULL; 1345 1346 if (cmds) 1347 { 1348 result = (struct command_line *) xmalloc (sizeof (struct command_line)); 1349 1350 result->next = copy_command_lines (cmds->next); 1351 result->line = xstrdup (cmds->line); 1352 result->control_type = cmds->control_type; 1353 result->body_count = cmds->body_count; 1354 if (cmds->body_count > 0) 1355 { 1356 int i; 1357 1358 result->body_list = (struct command_line **) 1359 xmalloc (sizeof (struct command_line *) * cmds->body_count); 1360 1361 for (i = 0; i < cmds->body_count; i++) 1362 result->body_list[i] = copy_command_lines (cmds->body_list[i]); 1363 } 1364 else 1365 result->body_list = NULL; 1366 } 1367 1368 return result; 1369 } 1370 1371 /* Validate that *COMNAME is a valid name for a command. Return the 1372 containing command list, in case it starts with a prefix command. 1373 The prefix must already exist. *COMNAME is advanced to point after 1374 any prefix, and a NUL character overwrites the space after the 1375 prefix. */ 1376 1377 static struct cmd_list_element ** 1378 validate_comname (char **comname) 1379 { 1380 struct cmd_list_element **list = &cmdlist; 1381 char *p, *last_word; 1382 1383 if (*comname == 0) 1384 error_no_arg (_("name of command to define")); 1385 1386 /* Find the last word of the argument. */ 1387 p = *comname + strlen (*comname); 1388 while (p > *comname && isspace (p[-1])) 1389 p--; 1390 while (p > *comname && !isspace (p[-1])) 1391 p--; 1392 last_word = p; 1393 1394 /* Find the corresponding command list. */ 1395 if (last_word != *comname) 1396 { 1397 struct cmd_list_element *c; 1398 char saved_char, *tem = *comname; 1399 1400 /* Separate the prefix and the command. */ 1401 saved_char = last_word[-1]; 1402 last_word[-1] = '\0'; 1403 1404 c = lookup_cmd (&tem, cmdlist, "", 0, 1); 1405 if (c->prefixlist == NULL) 1406 error (_("\"%s\" is not a prefix command."), *comname); 1407 1408 list = c->prefixlist; 1409 last_word[-1] = saved_char; 1410 *comname = last_word; 1411 } 1412 1413 p = *comname; 1414 while (*p) 1415 { 1416 if (!isalnum (*p) && *p != '-' && *p != '_') 1417 error (_("Junk in argument list: \"%s\""), p); 1418 p++; 1419 } 1420 1421 return list; 1422 } 1423 1424 /* This is just a placeholder in the command data structures. */ 1425 static void 1426 user_defined_command (char *ignore, int from_tty) 1427 { 1428 } 1429 1430 void 1431 define_command (char *comname, int from_tty) 1432 { 1433 #define MAX_TMPBUF 128 1434 enum cmd_hook_type 1435 { 1436 CMD_NO_HOOK = 0, 1437 CMD_PRE_HOOK, 1438 CMD_POST_HOOK 1439 }; 1440 struct command_line *cmds; 1441 struct cmd_list_element *c, *newc, *hookc = 0, **list; 1442 char *tem, *comfull; 1443 char tmpbuf[MAX_TMPBUF]; 1444 int hook_type = CMD_NO_HOOK; 1445 int hook_name_size = 0; 1446 1447 #define HOOK_STRING "hook-" 1448 #define HOOK_LEN 5 1449 #define HOOK_POST_STRING "hookpost-" 1450 #define HOOK_POST_LEN 9 1451 1452 comfull = comname; 1453 list = validate_comname (&comname); 1454 1455 /* Look it up, and verify that we got an exact match. */ 1456 tem = comname; 1457 c = lookup_cmd (&tem, *list, "", -1, 1); 1458 if (c && strcmp (comname, c->name) != 0) 1459 c = 0; 1460 1461 if (c) 1462 { 1463 int q; 1464 1465 if (c->class == class_user || c->class == class_alias) 1466 q = query (_("Redefine command \"%s\"? "), c->name); 1467 else 1468 q = query (_("Really redefine built-in command \"%s\"? "), c->name); 1469 if (!q) 1470 error (_("Command \"%s\" not redefined."), c->name); 1471 } 1472 1473 /* If this new command is a hook, then mark the command which it 1474 is hooking. Note that we allow hooking `help' commands, so that 1475 we can hook the `stop' pseudo-command. */ 1476 1477 if (!strncmp (comname, HOOK_STRING, HOOK_LEN)) 1478 { 1479 hook_type = CMD_PRE_HOOK; 1480 hook_name_size = HOOK_LEN; 1481 } 1482 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN)) 1483 { 1484 hook_type = CMD_POST_HOOK; 1485 hook_name_size = HOOK_POST_LEN; 1486 } 1487 1488 if (hook_type != CMD_NO_HOOK) 1489 { 1490 /* Look up cmd it hooks, and verify that we got an exact match. */ 1491 tem = comname + hook_name_size; 1492 hookc = lookup_cmd (&tem, *list, "", -1, 0); 1493 if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0) 1494 hookc = 0; 1495 if (!hookc) 1496 { 1497 warning (_("Your new `%s' command does not " 1498 "hook any existing command."), 1499 comfull); 1500 if (!query (_("Proceed? "))) 1501 error (_("Not confirmed.")); 1502 } 1503 } 1504 1505 comname = xstrdup (comname); 1506 1507 /* If the rest of the commands will be case insensitive, this one 1508 should behave in the same manner. */ 1509 for (tem = comname; *tem; tem++) 1510 if (isupper (*tem)) 1511 *tem = tolower (*tem); 1512 1513 sprintf (tmpbuf, "Type commands for definition of \"%s\".", comfull); 1514 cmds = read_command_lines (tmpbuf, from_tty, 1, 0, 0); 1515 1516 if (c && c->class == class_user) 1517 free_command_lines (&c->user_commands); 1518 1519 newc = add_cmd (comname, class_user, user_defined_command, 1520 (c && c->class == class_user) 1521 ? c->doc : xstrdup ("User-defined."), list); 1522 newc->user_commands = cmds; 1523 1524 /* If this new command is a hook, then mark both commands as being 1525 tied. */ 1526 if (hookc) 1527 { 1528 switch (hook_type) 1529 { 1530 case CMD_PRE_HOOK: 1531 hookc->hook_pre = newc; /* Target gets hooked. */ 1532 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */ 1533 break; 1534 case CMD_POST_HOOK: 1535 hookc->hook_post = newc; /* Target gets hooked. */ 1536 newc->hookee_post = hookc; /* We are marked as hooking 1537 target cmd. */ 1538 break; 1539 default: 1540 /* Should never come here as hookc would be 0. */ 1541 internal_error (__FILE__, __LINE__, _("bad switch")); 1542 } 1543 } 1544 } 1545 1546 void 1547 document_command (char *comname, int from_tty) 1548 { 1549 struct command_line *doclines; 1550 struct cmd_list_element *c, **list; 1551 char *tem, *comfull; 1552 char tmpbuf[128]; 1553 1554 comfull = comname; 1555 list = validate_comname (&comname); 1556 1557 tem = comname; 1558 c = lookup_cmd (&tem, *list, "", 0, 1); 1559 1560 if (c->class != class_user) 1561 error (_("Command \"%s\" is built-in."), comfull); 1562 1563 sprintf (tmpbuf, "Type documentation for \"%s\".", comfull); 1564 doclines = read_command_lines (tmpbuf, from_tty, 0, 0, 0); 1565 1566 if (c->doc) 1567 xfree (c->doc); 1568 1569 { 1570 struct command_line *cl1; 1571 int len = 0; 1572 1573 for (cl1 = doclines; cl1; cl1 = cl1->next) 1574 len += strlen (cl1->line) + 1; 1575 1576 c->doc = (char *) xmalloc (len + 1); 1577 *c->doc = 0; 1578 1579 for (cl1 = doclines; cl1; cl1 = cl1->next) 1580 { 1581 strcat (c->doc, cl1->line); 1582 if (cl1->next) 1583 strcat (c->doc, "\n"); 1584 } 1585 } 1586 1587 free_command_lines (&doclines); 1588 } 1589 1590 struct source_cleanup_lines_args 1591 { 1592 int old_line; 1593 const char *old_file; 1594 }; 1595 1596 static void 1597 source_cleanup_lines (void *args) 1598 { 1599 struct source_cleanup_lines_args *p = 1600 (struct source_cleanup_lines_args *) args; 1601 1602 source_line_number = p->old_line; 1603 source_file_name = p->old_file; 1604 } 1605 1606 /* Used to implement source_command. */ 1607 1608 void 1609 script_from_file (FILE *stream, const char *file) 1610 { 1611 struct cleanup *old_cleanups; 1612 struct source_cleanup_lines_args old_lines; 1613 1614 if (stream == NULL) 1615 internal_error (__FILE__, __LINE__, _("called with NULL file pointer!")); 1616 1617 old_cleanups = make_cleanup_fclose (stream); 1618 1619 old_lines.old_line = source_line_number; 1620 old_lines.old_file = source_file_name; 1621 make_cleanup (source_cleanup_lines, &old_lines); 1622 source_line_number = 0; 1623 source_file_name = file; 1624 /* This will get set every time we read a line. So it won't stay "" 1625 for long. */ 1626 error_pre_print = ""; 1627 1628 { 1629 volatile struct gdb_exception e; 1630 1631 TRY_CATCH (e, RETURN_MASK_ERROR) 1632 { 1633 read_command_file (stream); 1634 } 1635 switch (e.reason) 1636 { 1637 case 0: 1638 break; 1639 case RETURN_ERROR: 1640 /* Re-throw the error, but with the file name information 1641 prepended. */ 1642 throw_error (e.error, 1643 _("%s:%d: Error in sourced command file:\n%s"), 1644 source_file_name, source_line_number, e.message); 1645 default: 1646 internal_error (__FILE__, __LINE__, _("bad reason")); 1647 } 1648 } 1649 1650 do_cleanups (old_cleanups); 1651 } 1652 1653 /* Print the definition of user command C to STREAM. Or, if C is a 1654 prefix command, show the definitions of all user commands under C 1655 (recursively). PREFIX and NAME combined are the name of the 1656 current command. */ 1657 void 1658 show_user_1 (struct cmd_list_element *c, char *prefix, char *name, 1659 struct ui_file *stream) 1660 { 1661 struct command_line *cmdlines; 1662 1663 if (c->prefixlist != NULL) 1664 { 1665 char *prefixname = c->prefixname; 1666 1667 for (c = *c->prefixlist; c != NULL; c = c->next) 1668 if (c->class == class_user || c->prefixlist != NULL) 1669 show_user_1 (c, prefixname, c->name, gdb_stdout); 1670 return; 1671 } 1672 1673 cmdlines = c->user_commands; 1674 if (!cmdlines) 1675 return; 1676 fprintf_filtered (stream, "User command \"%s%s\":\n", prefix, name); 1677 1678 print_command_lines (current_uiout, cmdlines, 1); 1679 fputs_filtered ("\n", stream); 1680 } 1681 1682