1 /* Handle lists of commands, their decoding and documentation, for GDB. 2 3 Copyright (c) 1986, 1989, 1990, 1991, 1998, 2000, 2001, 2002, 2004, 2007, 4 2008, 2009 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #include "defs.h" 20 #include "symtab.h" 21 #include <ctype.h> 22 #include "gdb_regex.h" 23 #include "gdb_string.h" 24 #include "completer.h" 25 #include "ui-out.h" 26 27 #include "cli/cli-cmds.h" 28 #include "cli/cli-decode.h" 29 30 #ifdef TUI 31 #include "tui/tui.h" /* For tui_active et.al. */ 32 #endif 33 34 #include "gdb_assert.h" 35 36 /* Prototypes for local functions */ 37 38 static void undef_cmd_error (char *, char *); 39 40 static struct cmd_list_element *delete_cmd (char *name, 41 struct cmd_list_element **list, 42 struct cmd_list_element **prehook, 43 struct cmd_list_element **prehookee, 44 struct cmd_list_element **posthook, 45 struct cmd_list_element **posthookee); 46 47 static struct cmd_list_element *find_cmd (char *command, 48 int len, 49 struct cmd_list_element *clist, 50 int ignore_help_classes, 51 int *nfound); 52 53 static void help_all (struct ui_file *stream); 54 55 static void 56 print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse, 57 struct ui_file *stream); 58 59 60 /* Set the callback function for the specified command. For each both 61 the commands callback and func() are set. The latter set to a 62 bounce function (unless cfunc / sfunc is NULL that is). */ 63 64 static void 65 do_cfunc (struct cmd_list_element *c, char *args, int from_tty) 66 { 67 c->function.cfunc (args, from_tty); /* Ok. */ 68 } 69 70 void 71 set_cmd_cfunc (struct cmd_list_element *cmd, cmd_cfunc_ftype *cfunc) 72 { 73 if (cfunc == NULL) 74 cmd->func = NULL; 75 else 76 cmd->func = do_cfunc; 77 cmd->function.cfunc = cfunc; /* Ok. */ 78 } 79 80 static void 81 do_sfunc (struct cmd_list_element *c, char *args, int from_tty) 82 { 83 c->function.sfunc (args, from_tty, c); /* Ok. */ 84 } 85 86 void 87 set_cmd_sfunc (struct cmd_list_element *cmd, cmd_sfunc_ftype *sfunc) 88 { 89 if (sfunc == NULL) 90 cmd->func = NULL; 91 else 92 cmd->func = do_sfunc; 93 cmd->function.sfunc = sfunc; /* Ok. */ 94 } 95 96 int 97 cmd_cfunc_eq (struct cmd_list_element *cmd, 98 void (*cfunc) (char *args, int from_tty)) 99 { 100 return cmd->func == do_cfunc && cmd->function.cfunc == cfunc; 101 } 102 103 void 104 set_cmd_context (struct cmd_list_element *cmd, void *context) 105 { 106 cmd->context = context; 107 } 108 109 void * 110 get_cmd_context (struct cmd_list_element *cmd) 111 { 112 return cmd->context; 113 } 114 115 enum cmd_types 116 cmd_type (struct cmd_list_element *cmd) 117 { 118 return cmd->type; 119 } 120 121 void 122 set_cmd_completer (struct cmd_list_element *cmd, 123 char **(*completer) (struct cmd_list_element *self, 124 char *text, char *word)) 125 { 126 cmd->completer = completer; /* Ok. */ 127 } 128 129 130 /* Add element named NAME. 131 CLASS is the top level category into which commands are broken down 132 for "help" purposes. 133 FUN should be the function to execute the command; 134 it will get a character string as argument, with leading 135 and trailing blanks already eliminated. 136 137 DOC is a documentation string for the command. 138 Its first line should be a complete sentence. 139 It should start with ? for a command that is an abbreviation 140 or with * for a command that most users don't need to know about. 141 142 Add this command to command list *LIST. 143 144 Returns a pointer to the added command (not necessarily the head 145 of *LIST). */ 146 147 struct cmd_list_element * 148 add_cmd (char *name, enum command_class class, void (*fun) (char *, int), 149 char *doc, struct cmd_list_element **list) 150 { 151 struct cmd_list_element *c 152 = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element)); 153 struct cmd_list_element *p, *iter; 154 155 /* Turn each alias of the old command into an alias of the new 156 command. */ 157 c->aliases = delete_cmd (name, list, &c->hook_pre, &c->hookee_pre, 158 &c->hook_post, &c->hookee_post); 159 for (iter = c->aliases; iter; iter = iter->alias_chain) 160 iter->cmd_pointer = c; 161 if (c->hook_pre) 162 c->hook_pre->hookee_pre = c; 163 if (c->hookee_pre) 164 c->hookee_pre->hook_pre = c; 165 if (c->hook_post) 166 c->hook_post->hookee_post = c; 167 if (c->hookee_post) 168 c->hookee_post->hook_post = c; 169 170 if (*list == NULL || strcmp ((*list)->name, name) >= 0) 171 { 172 c->next = *list; 173 *list = c; 174 } 175 else 176 { 177 p = *list; 178 while (p->next && strcmp (p->next->name, name) <= 0) 179 { 180 p = p->next; 181 } 182 c->next = p->next; 183 p->next = c; 184 } 185 186 c->name = name; 187 c->class = class; 188 set_cmd_cfunc (c, fun); 189 set_cmd_context (c, NULL); 190 c->doc = doc; 191 c->flags = 0; 192 c->replacement = NULL; 193 c->pre_show_hook = NULL; 194 c->hook_in = 0; 195 c->prefixlist = NULL; 196 c->prefixname = NULL; 197 c->allow_unknown = 0; 198 c->abbrev_flag = 0; 199 set_cmd_completer (c, make_symbol_completion_list_fn); 200 c->destroyer = NULL; 201 c->type = not_set_cmd; 202 c->var = NULL; 203 c->var_type = var_boolean; 204 c->enums = NULL; 205 c->user_commands = NULL; 206 c->cmd_pointer = NULL; 207 c->alias_chain = NULL; 208 209 return c; 210 } 211 212 /* Deprecates a command CMD. 213 REPLACEMENT is the name of the command which should be used in place 214 of this command, or NULL if no such command exists. 215 216 This function does not check to see if command REPLACEMENT exists 217 since gdb may not have gotten around to adding REPLACEMENT when this 218 function is called. 219 220 Returns a pointer to the deprecated command. */ 221 222 struct cmd_list_element * 223 deprecate_cmd (struct cmd_list_element *cmd, char *replacement) 224 { 225 cmd->flags |= (CMD_DEPRECATED | DEPRECATED_WARN_USER); 226 227 if (replacement != NULL) 228 cmd->replacement = replacement; 229 else 230 cmd->replacement = NULL; 231 232 return cmd; 233 } 234 235 struct cmd_list_element * 236 add_alias_cmd (char *name, char *oldname, enum command_class class, 237 int abbrev_flag, struct cmd_list_element **list) 238 { 239 /* Must do this since lookup_cmd tries to side-effect its first arg */ 240 char *copied_name; 241 struct cmd_list_element *old; 242 struct cmd_list_element *c; 243 copied_name = (char *) alloca (strlen (oldname) + 1); 244 strcpy (copied_name, oldname); 245 old = lookup_cmd (&copied_name, *list, "", 1, 1); 246 247 if (old == 0) 248 { 249 struct cmd_list_element *prehook, *prehookee, *posthook, *posthookee; 250 struct cmd_list_element *aliases = delete_cmd (name, list, 251 &prehook, &prehookee, 252 &posthook, &posthookee); 253 /* If this happens, it means a programmer error somewhere. */ 254 gdb_assert (!aliases && !prehook && !prehookee 255 && !posthook && ! posthookee); 256 return 0; 257 } 258 259 c = add_cmd (name, class, NULL, old->doc, list); 260 /* NOTE: Both FUNC and all the FUNCTIONs need to be copied. */ 261 c->func = old->func; 262 c->function = old->function; 263 c->prefixlist = old->prefixlist; 264 c->prefixname = old->prefixname; 265 c->allow_unknown = old->allow_unknown; 266 c->abbrev_flag = abbrev_flag; 267 c->cmd_pointer = old; 268 c->alias_chain = old->aliases; 269 old->aliases = c; 270 return c; 271 } 272 273 /* Like add_cmd but adds an element for a command prefix: 274 a name that should be followed by a subcommand to be looked up 275 in another command list. PREFIXLIST should be the address 276 of the variable containing that list. */ 277 278 struct cmd_list_element * 279 add_prefix_cmd (char *name, enum command_class class, void (*fun) (char *, int), 280 char *doc, struct cmd_list_element **prefixlist, 281 char *prefixname, int allow_unknown, 282 struct cmd_list_element **list) 283 { 284 struct cmd_list_element *c = add_cmd (name, class, fun, doc, list); 285 c->prefixlist = prefixlist; 286 c->prefixname = prefixname; 287 c->allow_unknown = allow_unknown; 288 return c; 289 } 290 291 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */ 292 293 struct cmd_list_element * 294 add_abbrev_prefix_cmd (char *name, enum command_class class, 295 void (*fun) (char *, int), char *doc, 296 struct cmd_list_element **prefixlist, char *prefixname, 297 int allow_unknown, struct cmd_list_element **list) 298 { 299 struct cmd_list_element *c = add_cmd (name, class, fun, doc, list); 300 c->prefixlist = prefixlist; 301 c->prefixname = prefixname; 302 c->allow_unknown = allow_unknown; 303 c->abbrev_flag = 1; 304 return c; 305 } 306 307 /* This is an empty "cfunc". */ 308 void 309 not_just_help_class_command (char *args, int from_tty) 310 { 311 } 312 313 /* This is an empty "sfunc". */ 314 static void empty_sfunc (char *, int, struct cmd_list_element *); 315 316 static void 317 empty_sfunc (char *args, int from_tty, struct cmd_list_element *c) 318 { 319 } 320 321 /* Add element named NAME to command list LIST (the list for set/show 322 or some sublist thereof). 323 TYPE is set_cmd or show_cmd. 324 CLASS is as in add_cmd. 325 VAR_TYPE is the kind of thing we are setting. 326 VAR is address of the variable being controlled by this command. 327 DOC is the documentation string. */ 328 329 static struct cmd_list_element * 330 add_set_or_show_cmd (char *name, 331 enum cmd_types type, 332 enum command_class class, 333 var_types var_type, 334 void *var, 335 char *doc, 336 struct cmd_list_element **list) 337 { 338 struct cmd_list_element *c = add_cmd (name, class, NULL, doc, list); 339 gdb_assert (type == set_cmd || type == show_cmd); 340 c->type = type; 341 c->var_type = var_type; 342 c->var = var; 343 /* This needs to be something besides NULL so that this isn't 344 treated as a help class. */ 345 set_cmd_sfunc (c, empty_sfunc); 346 return c; 347 } 348 349 /* Add element named NAME to both the command SET_LIST and SHOW_LIST. 350 CLASS is as in add_cmd. VAR_TYPE is the kind of thing we are 351 setting. VAR is address of the variable being controlled by this 352 command. SET_FUNC and SHOW_FUNC are the callback functions (if 353 non-NULL). SET_DOC, SHOW_DOC and HELP_DOC are the documentation 354 strings. PRINT the format string to print the value. SET_RESULT 355 and SHOW_RESULT, if not NULL, are set to the resulting command 356 structures. */ 357 358 static void 359 add_setshow_cmd_full (char *name, 360 enum command_class class, 361 var_types var_type, void *var, 362 const char *set_doc, const char *show_doc, 363 const char *help_doc, 364 cmd_sfunc_ftype *set_func, 365 show_value_ftype *show_func, 366 struct cmd_list_element **set_list, 367 struct cmd_list_element **show_list, 368 struct cmd_list_element **set_result, 369 struct cmd_list_element **show_result) 370 { 371 struct cmd_list_element *set; 372 struct cmd_list_element *show; 373 char *full_set_doc; 374 char *full_show_doc; 375 376 if (help_doc != NULL) 377 { 378 full_set_doc = xstrprintf ("%s\n%s", set_doc, help_doc); 379 full_show_doc = xstrprintf ("%s\n%s", show_doc, help_doc); 380 } 381 else 382 { 383 full_set_doc = xstrdup (set_doc); 384 full_show_doc = xstrdup (show_doc); 385 } 386 set = add_set_or_show_cmd (name, set_cmd, class, var_type, var, 387 full_set_doc, set_list); 388 if (set_func != NULL) 389 set_cmd_sfunc (set, set_func); 390 show = add_set_or_show_cmd (name, show_cmd, class, var_type, var, 391 full_show_doc, show_list); 392 show->show_value_func = show_func; 393 394 if (set_result != NULL) 395 *set_result = set; 396 if (show_result != NULL) 397 *show_result = show; 398 } 399 400 /* Add element named NAME to command list LIST (the list for set or 401 some sublist thereof). CLASS is as in add_cmd. ENUMLIST is a list 402 of strings which may follow NAME. VAR is address of the variable 403 which will contain the matching string (from ENUMLIST). */ 404 405 void 406 add_setshow_enum_cmd (char *name, 407 enum command_class class, 408 const char *enumlist[], 409 const char **var, 410 const char *set_doc, 411 const char *show_doc, 412 const char *help_doc, 413 cmd_sfunc_ftype *set_func, 414 show_value_ftype *show_func, 415 struct cmd_list_element **set_list, 416 struct cmd_list_element **show_list) 417 { 418 struct cmd_list_element *c; 419 add_setshow_cmd_full (name, class, var_enum, var, 420 set_doc, show_doc, help_doc, 421 set_func, show_func, 422 set_list, show_list, 423 &c, NULL); 424 c->enums = enumlist; 425 } 426 427 /* Add an auto-boolean command named NAME to both the set and show 428 command list lists. CLASS is as in add_cmd. VAR is address of the 429 variable which will contain the value. DOC is the documentation 430 string. FUNC is the corresponding callback. */ 431 void 432 add_setshow_auto_boolean_cmd (char *name, 433 enum command_class class, 434 enum auto_boolean *var, 435 const char *set_doc, const char *show_doc, 436 const char *help_doc, 437 cmd_sfunc_ftype *set_func, 438 show_value_ftype *show_func, 439 struct cmd_list_element **set_list, 440 struct cmd_list_element **show_list) 441 { 442 static const char *auto_boolean_enums[] = { "on", "off", "auto", NULL }; 443 struct cmd_list_element *c; 444 add_setshow_cmd_full (name, class, var_auto_boolean, var, 445 set_doc, show_doc, help_doc, 446 set_func, show_func, 447 set_list, show_list, 448 &c, NULL); 449 c->enums = auto_boolean_enums; 450 } 451 452 /* Add element named NAME to both the set and show command LISTs (the 453 list for set/show or some sublist thereof). CLASS is as in 454 add_cmd. VAR is address of the variable which will contain the 455 value. SET_DOC and SHOW_DOC are the documentation strings. */ 456 void 457 add_setshow_boolean_cmd (char *name, enum command_class class, int *var, 458 const char *set_doc, const char *show_doc, 459 const char *help_doc, 460 cmd_sfunc_ftype *set_func, 461 show_value_ftype *show_func, 462 struct cmd_list_element **set_list, 463 struct cmd_list_element **show_list) 464 { 465 static const char *boolean_enums[] = { "on", "off", NULL }; 466 struct cmd_list_element *c; 467 add_setshow_cmd_full (name, class, var_boolean, var, 468 set_doc, show_doc, help_doc, 469 set_func, show_func, 470 set_list, show_list, 471 &c, NULL); 472 c->enums = boolean_enums; 473 } 474 475 /* Add element named NAME to both the set and show command LISTs (the 476 list for set/show or some sublist thereof). */ 477 void 478 add_setshow_filename_cmd (char *name, enum command_class class, 479 char **var, 480 const char *set_doc, const char *show_doc, 481 const char *help_doc, 482 cmd_sfunc_ftype *set_func, 483 show_value_ftype *show_func, 484 struct cmd_list_element **set_list, 485 struct cmd_list_element **show_list) 486 { 487 struct cmd_list_element *set_result; 488 add_setshow_cmd_full (name, class, var_filename, var, 489 set_doc, show_doc, help_doc, 490 set_func, show_func, 491 set_list, show_list, 492 &set_result, NULL); 493 set_cmd_completer (set_result, filename_completer); 494 } 495 496 /* Add element named NAME to both the set and show command LISTs (the 497 list for set/show or some sublist thereof). */ 498 void 499 add_setshow_string_cmd (char *name, enum command_class class, 500 char **var, 501 const char *set_doc, const char *show_doc, 502 const char *help_doc, 503 cmd_sfunc_ftype *set_func, 504 show_value_ftype *show_func, 505 struct cmd_list_element **set_list, 506 struct cmd_list_element **show_list) 507 { 508 add_setshow_cmd_full (name, class, var_string, var, 509 set_doc, show_doc, help_doc, 510 set_func, show_func, 511 set_list, show_list, 512 NULL, NULL); 513 } 514 515 /* Add element named NAME to both the set and show command LISTs (the 516 list for set/show or some sublist thereof). */ 517 void 518 add_setshow_string_noescape_cmd (char *name, enum command_class class, 519 char **var, 520 const char *set_doc, const char *show_doc, 521 const char *help_doc, 522 cmd_sfunc_ftype *set_func, 523 show_value_ftype *show_func, 524 struct cmd_list_element **set_list, 525 struct cmd_list_element **show_list) 526 { 527 add_setshow_cmd_full (name, class, var_string_noescape, var, 528 set_doc, show_doc, help_doc, 529 set_func, show_func, 530 set_list, show_list, 531 NULL, NULL); 532 } 533 534 /* Add element named NAME to both the set and show command LISTs (the 535 list for set/show or some sublist thereof). */ 536 void 537 add_setshow_optional_filename_cmd (char *name, enum command_class class, 538 char **var, 539 const char *set_doc, const char *show_doc, 540 const char *help_doc, 541 cmd_sfunc_ftype *set_func, 542 show_value_ftype *show_func, 543 struct cmd_list_element **set_list, 544 struct cmd_list_element **show_list) 545 { 546 struct cmd_list_element *set_result; 547 548 add_setshow_cmd_full (name, class, var_optional_filename, var, 549 set_doc, show_doc, help_doc, 550 set_func, show_func, 551 set_list, show_list, 552 &set_result, NULL); 553 554 set_cmd_completer (set_result, filename_completer); 555 556 } 557 558 /* Add element named NAME to both the set and show command LISTs (the 559 list for set/show or some sublist thereof). CLASS is as in 560 add_cmd. VAR is address of the variable which will contain the 561 value. SET_DOC and SHOW_DOC are the documentation strings. */ 562 void 563 add_setshow_integer_cmd (char *name, enum command_class class, 564 int *var, 565 const char *set_doc, const char *show_doc, 566 const char *help_doc, 567 cmd_sfunc_ftype *set_func, 568 show_value_ftype *show_func, 569 struct cmd_list_element **set_list, 570 struct cmd_list_element **show_list) 571 { 572 add_setshow_cmd_full (name, class, var_integer, var, 573 set_doc, show_doc, help_doc, 574 set_func, show_func, 575 set_list, show_list, 576 NULL, NULL); 577 } 578 579 /* Add element named NAME to both the set and show command LISTs (the 580 list for set/show or some sublist thereof). CLASS is as in 581 add_cmd. VAR is address of the variable which will contain the 582 value. SET_DOC and SHOW_DOC are the documentation strings. */ 583 void 584 add_setshow_uinteger_cmd (char *name, enum command_class class, 585 unsigned int *var, 586 const char *set_doc, const char *show_doc, 587 const char *help_doc, 588 cmd_sfunc_ftype *set_func, 589 show_value_ftype *show_func, 590 struct cmd_list_element **set_list, 591 struct cmd_list_element **show_list) 592 { 593 add_setshow_cmd_full (name, class, var_uinteger, var, 594 set_doc, show_doc, help_doc, 595 set_func, show_func, 596 set_list, show_list, 597 NULL, NULL); 598 } 599 600 /* Add element named NAME to both the set and show command LISTs (the 601 list for set/show or some sublist thereof). CLASS is as in 602 add_cmd. VAR is address of the variable which will contain the 603 value. SET_DOC and SHOW_DOC are the documentation strings. */ 604 void 605 add_setshow_zinteger_cmd (char *name, enum command_class class, 606 int *var, 607 const char *set_doc, const char *show_doc, 608 const char *help_doc, 609 cmd_sfunc_ftype *set_func, 610 show_value_ftype *show_func, 611 struct cmd_list_element **set_list, 612 struct cmd_list_element **show_list) 613 { 614 add_setshow_cmd_full (name, class, var_zinteger, var, 615 set_doc, show_doc, help_doc, 616 set_func, show_func, 617 set_list, show_list, 618 NULL, NULL); 619 } 620 621 /* Add element named NAME to both the set and show command LISTs (the 622 list for set/show or some sublist thereof). CLASS is as in 623 add_cmd. VAR is address of the variable which will contain the 624 value. SET_DOC and SHOW_DOC are the documentation strings. */ 625 void 626 add_setshow_zuinteger_cmd (char *name, enum command_class class, 627 unsigned int *var, 628 const char *set_doc, const char *show_doc, 629 const char *help_doc, 630 cmd_sfunc_ftype *set_func, 631 show_value_ftype *show_func, 632 struct cmd_list_element **set_list, 633 struct cmd_list_element **show_list) 634 { 635 add_setshow_cmd_full (name, class, var_zuinteger, var, 636 set_doc, show_doc, help_doc, 637 set_func, show_func, 638 set_list, show_list, 639 NULL, NULL); 640 } 641 642 /* Remove the command named NAME from the command list. Return the 643 list commands which were aliased to the deleted command. If the 644 command had no aliases, return NULL. The various *HOOKs are set to 645 the pre- and post-hook commands for the deleted command. If the 646 command does not have a hook, the corresponding out parameter is 647 set to NULL. */ 648 649 static struct cmd_list_element * 650 delete_cmd (char *name, struct cmd_list_element **list, 651 struct cmd_list_element **prehook, 652 struct cmd_list_element **prehookee, 653 struct cmd_list_element **posthook, 654 struct cmd_list_element **posthookee) 655 { 656 struct cmd_list_element *iter; 657 struct cmd_list_element **previous_chain_ptr; 658 struct cmd_list_element *aliases = NULL; 659 660 *prehook = NULL; 661 *prehookee = NULL; 662 *posthook = NULL; 663 *posthookee = NULL; 664 previous_chain_ptr = list; 665 666 for (iter = *previous_chain_ptr; iter; iter = *previous_chain_ptr) 667 { 668 if (strcmp (iter->name, name) == 0) 669 { 670 if (iter->destroyer) 671 iter->destroyer (iter, iter->context); 672 if (iter->hookee_pre) 673 iter->hookee_pre->hook_pre = 0; 674 *prehook = iter->hook_pre; 675 *prehookee = iter->hookee_pre; 676 if (iter->hookee_post) 677 iter->hookee_post->hook_post = 0; 678 *posthook = iter->hook_post; 679 *posthookee = iter->hookee_post; 680 681 /* Update the link. */ 682 *previous_chain_ptr = iter->next; 683 684 aliases = iter->aliases; 685 686 /* If this command was an alias, remove it from the list of 687 aliases. */ 688 if (iter->cmd_pointer) 689 { 690 struct cmd_list_element **prevp = &iter->cmd_pointer->aliases; 691 struct cmd_list_element *a = *prevp; 692 693 while (a != iter) 694 { 695 prevp = &a->alias_chain; 696 a = *prevp; 697 } 698 *prevp = iter->alias_chain; 699 } 700 701 xfree (iter); 702 703 /* We won't see another command with the same name. */ 704 break; 705 } 706 else 707 previous_chain_ptr = &iter->next; 708 } 709 710 return aliases; 711 } 712 713 /* Shorthands to the commands above. */ 714 715 /* Add an element to the list of info subcommands. */ 716 717 struct cmd_list_element * 718 add_info (char *name, void (*fun) (char *, int), char *doc) 719 { 720 return add_cmd (name, no_class, fun, doc, &infolist); 721 } 722 723 /* Add an alias to the list of info subcommands. */ 724 725 struct cmd_list_element * 726 add_info_alias (char *name, char *oldname, int abbrev_flag) 727 { 728 return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist); 729 } 730 731 /* Add an element to the list of commands. */ 732 733 struct cmd_list_element * 734 add_com (char *name, enum command_class class, void (*fun) (char *, int), 735 char *doc) 736 { 737 return add_cmd (name, class, fun, doc, &cmdlist); 738 } 739 740 /* Add an alias or abbreviation command to the list of commands. */ 741 742 struct cmd_list_element * 743 add_com_alias (char *name, char *oldname, enum command_class class, 744 int abbrev_flag) 745 { 746 return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist); 747 } 748 749 /* Recursively walk the commandlist structures, and print out the 750 documentation of commands that match our regex in either their 751 name, or their documentation. 752 */ 753 void 754 apropos_cmd (struct ui_file *stream, struct cmd_list_element *commandlist, 755 struct re_pattern_buffer *regex, char *prefix) 756 { 757 struct cmd_list_element *c; 758 int returnvalue; 759 /* Walk through the commands */ 760 for (c=commandlist;c;c=c->next) 761 { 762 returnvalue = -1; /*Needed to avoid double printing*/ 763 if (c->name != NULL) 764 { 765 /* Try to match against the name*/ 766 returnvalue=re_search(regex,c->name,strlen(c->name),0,strlen(c->name),NULL); 767 if (returnvalue >= 0) 768 { 769 print_help_for_command (c, prefix, 770 0 /* don't recurse */, stream); 771 } 772 } 773 if (c->doc != NULL && returnvalue < 0) 774 { 775 /* Try to match against documentation */ 776 if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0) 777 { 778 print_help_for_command (c, prefix, 779 0 /* don't recurse */, stream); 780 } 781 } 782 /* Check if this command has subcommands and is not an abbreviation. 783 We skip listing subcommands of abbreviations in order to avoid 784 duplicates in the output. 785 */ 786 if (c->prefixlist != NULL && !c->abbrev_flag) 787 { 788 /* Recursively call ourselves on the subcommand list, 789 passing the right prefix in. 790 */ 791 apropos_cmd (stream,*c->prefixlist,regex,c->prefixname); 792 } 793 } 794 } 795 796 /* This command really has to deal with two things: 797 * 1) I want documentation on *this string* (usually called by 798 * "help commandname"). 799 * 2) I want documentation on *this list* (usually called by 800 * giving a command that requires subcommands. Also called by saying 801 * just "help".) 802 * 803 * I am going to split this into two seperate comamnds, help_cmd and 804 * help_list. 805 */ 806 807 void 808 help_cmd (char *command, struct ui_file *stream) 809 { 810 struct cmd_list_element *c; 811 extern struct cmd_list_element *cmdlist; 812 813 if (!command) 814 { 815 help_list (cmdlist, "", all_classes, stream); 816 return; 817 } 818 819 if (strcmp (command, "all") == 0) 820 { 821 help_all (stream); 822 return; 823 } 824 825 c = lookup_cmd (&command, cmdlist, "", 0, 0); 826 827 if (c == 0) 828 return; 829 830 /* There are three cases here. 831 If c->prefixlist is nonzero, we have a prefix command. 832 Print its documentation, then list its subcommands. 833 834 If c->func is non NULL, we really have a command. Print its 835 documentation and return. 836 837 If c->func is NULL, we have a class name. Print its 838 documentation (as if it were a command) and then set class to the 839 number of this class so that the commands in the class will be 840 listed. */ 841 842 fputs_filtered (c->doc, stream); 843 fputs_filtered ("\n", stream); 844 845 if (c->prefixlist == 0 && c->func != NULL) 846 return; 847 fprintf_filtered (stream, "\n"); 848 849 /* If this is a prefix command, print it's subcommands */ 850 if (c->prefixlist) 851 help_list (*c->prefixlist, c->prefixname, all_commands, stream); 852 853 /* If this is a class name, print all of the commands in the class */ 854 if (c->func == NULL) 855 help_list (cmdlist, "", c->class, stream); 856 857 if (c->hook_pre || c->hook_post) 858 fprintf_filtered (stream, 859 "\nThis command has a hook (or hooks) defined:\n"); 860 861 if (c->hook_pre) 862 fprintf_filtered (stream, 863 "\tThis command is run after : %s (pre hook)\n", 864 c->hook_pre->name); 865 if (c->hook_post) 866 fprintf_filtered (stream, 867 "\tThis command is run before : %s (post hook)\n", 868 c->hook_post->name); 869 } 870 871 /* 872 * Get a specific kind of help on a command list. 873 * 874 * LIST is the list. 875 * CMDTYPE is the prefix to use in the title string. 876 * CLASS is the class with which to list the nodes of this list (see 877 * documentation for help_cmd_list below), As usual, ALL_COMMANDS for 878 * everything, ALL_CLASSES for just classes, and non-negative for only things 879 * in a specific class. 880 * and STREAM is the output stream on which to print things. 881 * If you call this routine with a class >= 0, it recurses. 882 */ 883 void 884 help_list (struct cmd_list_element *list, char *cmdtype, 885 enum command_class class, struct ui_file *stream) 886 { 887 int len; 888 char *cmdtype1, *cmdtype2; 889 890 /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */ 891 len = strlen (cmdtype); 892 cmdtype1 = (char *) alloca (len + 1); 893 cmdtype1[0] = 0; 894 cmdtype2 = (char *) alloca (len + 4); 895 cmdtype2[0] = 0; 896 if (len) 897 { 898 cmdtype1[0] = ' '; 899 strncpy (cmdtype1 + 1, cmdtype, len - 1); 900 cmdtype1[len] = 0; 901 strncpy (cmdtype2, cmdtype, len - 1); 902 strcpy (cmdtype2 + len - 1, " sub"); 903 } 904 905 if (class == all_classes) 906 fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2); 907 else 908 fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2); 909 910 help_cmd_list (list, class, cmdtype, (int) class >= 0, stream); 911 912 if (class == all_classes) 913 { 914 fprintf_filtered (stream, "\n\ 915 Type \"help%s\" followed by a class name for a list of commands in ", 916 cmdtype1); 917 wrap_here (""); 918 fprintf_filtered (stream, "that class."); 919 920 fprintf_filtered (stream, "\n\ 921 Type \"help all\" for the list of all commands."); 922 } 923 924 fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ", 925 cmdtype1, cmdtype2); 926 wrap_here (""); 927 fputs_filtered ("for ", stream); 928 wrap_here (""); 929 fputs_filtered ("full ", stream); 930 wrap_here (""); 931 fputs_filtered ("documentation.\n", stream); 932 fputs_filtered ("Type \"apropos word\" to search " 933 "for commands related to \"word\".\n", stream); 934 fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n", 935 stream); 936 } 937 938 static void 939 help_all (struct ui_file *stream) 940 { 941 struct cmd_list_element *c; 942 extern struct cmd_list_element *cmdlist; 943 int seen_unclassified = 0; 944 945 for (c = cmdlist; c; c = c->next) 946 { 947 if (c->abbrev_flag) 948 continue; 949 /* If this is a class name, print all of the commands in the class */ 950 951 if (c->func == NULL) 952 { 953 fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name); 954 help_cmd_list (cmdlist, c->class, "", 1, stream); 955 } 956 } 957 958 /* While it's expected that all commands are in some class, 959 as a safety measure, we'll print commands outside of any 960 class at the end. */ 961 962 for (c = cmdlist; c; c = c->next) 963 { 964 if (c->abbrev_flag) 965 continue; 966 967 if (c->class == no_class) 968 { 969 if (!seen_unclassified) 970 { 971 fprintf_filtered (stream, "\nUnclassified commands\n\n"); 972 seen_unclassified = 1; 973 } 974 print_help_for_command (c, "", 1, stream); 975 } 976 } 977 978 } 979 980 /* Print only the first line of STR on STREAM. */ 981 void 982 print_doc_line (struct ui_file *stream, char *str) 983 { 984 static char *line_buffer = 0; 985 static int line_size; 986 char *p; 987 988 if (!line_buffer) 989 { 990 line_size = 80; 991 line_buffer = (char *) xmalloc (line_size); 992 } 993 994 p = str; 995 while (*p && *p != '\n' && *p != '.' && *p != ',') 996 p++; 997 if (p - str > line_size - 1) 998 { 999 line_size = p - str + 1; 1000 xfree (line_buffer); 1001 line_buffer = (char *) xmalloc (line_size); 1002 } 1003 strncpy (line_buffer, str, p - str); 1004 line_buffer[p - str] = '\0'; 1005 if (islower (line_buffer[0])) 1006 line_buffer[0] = toupper (line_buffer[0]); 1007 ui_out_text (uiout, line_buffer); 1008 } 1009 1010 /* Print one-line help for command C. 1011 If RECURSE is non-zero, also print one-line descriptions 1012 of all prefixed subcommands. */ 1013 static void 1014 print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse, 1015 struct ui_file *stream) 1016 { 1017 fprintf_filtered (stream, "%s%s -- ", prefix, c->name); 1018 print_doc_line (stream, c->doc); 1019 fputs_filtered ("\n", stream); 1020 1021 if (recurse 1022 && c->prefixlist != 0 1023 && c->abbrev_flag == 0) 1024 /* Subcommands of a prefix command typically have 'all_commands' 1025 as class. If we pass CLASS to recursive invocation, 1026 most often we won't see anything. */ 1027 help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream); 1028 } 1029 1030 /* 1031 * Implement a help command on command list LIST. 1032 * RECURSE should be non-zero if this should be done recursively on 1033 * all sublists of LIST. 1034 * PREFIX is the prefix to print before each command name. 1035 * STREAM is the stream upon which the output should be written. 1036 * CLASS should be: 1037 * A non-negative class number to list only commands in that 1038 * class. 1039 * ALL_COMMANDS to list all commands in list. 1040 * ALL_CLASSES to list all classes in list. 1041 * 1042 * Note that RECURSE will be active on *all* sublists, not just the 1043 * ones selected by the criteria above (ie. the selection mechanism 1044 * is at the low level, not the high-level). 1045 */ 1046 void 1047 help_cmd_list (struct cmd_list_element *list, enum command_class class, 1048 char *prefix, int recurse, struct ui_file *stream) 1049 { 1050 struct cmd_list_element *c; 1051 1052 for (c = list; c; c = c->next) 1053 { 1054 if (c->abbrev_flag == 0 && 1055 (class == all_commands 1056 || (class == all_classes && c->func == NULL) 1057 || (class == c->class && c->func != NULL))) 1058 { 1059 print_help_for_command (c, prefix, recurse, stream); 1060 } 1061 else if (c->abbrev_flag == 0 && recurse 1062 && class == class_user && c->prefixlist != NULL) 1063 /* User-defined commands may be subcommands. */ 1064 help_cmd_list (*c->prefixlist, class, c->prefixname, recurse, stream); 1065 } 1066 } 1067 1068 1069 /* Search the input clist for 'command'. Return the command if 1070 found (or NULL if not), and return the number of commands 1071 found in nfound */ 1072 1073 static struct cmd_list_element * 1074 find_cmd (char *command, int len, struct cmd_list_element *clist, 1075 int ignore_help_classes, int *nfound) 1076 { 1077 struct cmd_list_element *found, *c; 1078 1079 found = (struct cmd_list_element *) NULL; 1080 *nfound = 0; 1081 for (c = clist; c; c = c->next) 1082 if (!strncmp (command, c->name, len) 1083 && (!ignore_help_classes || c->func)) 1084 { 1085 found = c; 1086 (*nfound)++; 1087 if (c->name[len] == '\0') 1088 { 1089 *nfound = 1; 1090 break; 1091 } 1092 } 1093 return found; 1094 } 1095 1096 static int 1097 find_command_name_length (const char *text) 1098 { 1099 const char *p = text; 1100 1101 /* Treating underscores as part of command words is important 1102 so that "set args_foo()" doesn't get interpreted as 1103 "set args _foo()". */ 1104 /* Some characters are only used for TUI specific commands. However, they 1105 are always allowed for the sake of consistency. 1106 The XDB compatibility characters are only allowed when using the right 1107 mode because they clash with other GDB commands - specifically '/' is 1108 used as a suffix for print, examine and display. 1109 Note that this is larger than the character set allowed when creating 1110 user-defined commands. */ 1111 while (isalnum (*p) || *p == '-' || *p == '_' || 1112 /* Characters used by TUI specific commands. */ 1113 *p == '+' || *p == '<' || *p == '>' || *p == '$' || 1114 /* Characters used for XDB compatibility. */ 1115 (xdb_commands && (*p == '!' || *p == '/' || *p == '?'))) 1116 p++; 1117 1118 return p - text; 1119 } 1120 1121 /* This routine takes a line of TEXT and a CLIST in which to start the 1122 lookup. When it returns it will have incremented the text pointer past 1123 the section of text it matched, set *RESULT_LIST to point to the list in 1124 which the last word was matched, and will return a pointer to the cmd 1125 list element which the text matches. It will return NULL if no match at 1126 all was possible. It will return -1 (cast appropriately, ick) if ambigous 1127 matches are possible; in this case *RESULT_LIST will be set to point to 1128 the list in which there are ambiguous choices (and *TEXT will be set to 1129 the ambiguous text string). 1130 1131 If the located command was an abbreviation, this routine returns the base 1132 command of the abbreviation. 1133 1134 It does no error reporting whatsoever; control will always return 1135 to the superior routine. 1136 1137 In the case of an ambiguous return (-1), *RESULT_LIST will be set to point 1138 at the prefix_command (ie. the best match) *or* (special case) will be NULL 1139 if no prefix command was ever found. For example, in the case of "info a", 1140 "info" matches without ambiguity, but "a" could be "args" or "address", so 1141 *RESULT_LIST is set to the cmd_list_element for "info". So in this case 1142 RESULT_LIST should not be interpeted as a pointer to the beginning of a 1143 list; it simply points to a specific command. In the case of an ambiguous 1144 return *TEXT is advanced past the last non-ambiguous prefix (e.g. 1145 "info t" can be "info types" or "info target"; upon return *TEXT has been 1146 advanced past "info "). 1147 1148 If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise 1149 affect the operation). 1150 1151 This routine does *not* modify the text pointed to by TEXT. 1152 1153 If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which 1154 are actually help classes rather than commands (i.e. the function field of 1155 the struct cmd_list_element is NULL). */ 1156 1157 struct cmd_list_element * 1158 lookup_cmd_1 (char **text, struct cmd_list_element *clist, 1159 struct cmd_list_element **result_list, int ignore_help_classes) 1160 { 1161 char *command; 1162 int len, tmp, nfound; 1163 struct cmd_list_element *found, *c; 1164 char *line = *text; 1165 1166 while (**text == ' ' || **text == '\t') 1167 (*text)++; 1168 1169 /* Identify the name of the command. */ 1170 len = find_command_name_length (*text); 1171 1172 /* If nothing but whitespace, return 0. */ 1173 if (len == 0) 1174 return 0; 1175 1176 /* *text and p now bracket the first command word to lookup (and 1177 it's length is len). We copy this into a local temporary */ 1178 1179 1180 command = (char *) alloca (len + 1); 1181 memcpy (command, *text, len); 1182 command[len] = '\0'; 1183 1184 /* Look it up. */ 1185 found = 0; 1186 nfound = 0; 1187 found = find_cmd (command, len, clist, ignore_help_classes, &nfound); 1188 1189 /* 1190 ** We didn't find the command in the entered case, so lower case it 1191 ** and search again. 1192 */ 1193 if (!found || nfound == 0) 1194 { 1195 for (tmp = 0; tmp < len; tmp++) 1196 { 1197 char x = command[tmp]; 1198 command[tmp] = isupper (x) ? tolower (x) : x; 1199 } 1200 found = find_cmd (command, len, clist, ignore_help_classes, &nfound); 1201 } 1202 1203 /* If nothing matches, we have a simple failure. */ 1204 if (nfound == 0) 1205 return 0; 1206 1207 if (nfound > 1) 1208 { 1209 if (result_list != NULL) 1210 /* Will be modified in calling routine 1211 if we know what the prefix command is. */ 1212 *result_list = 0; 1213 return (struct cmd_list_element *) -1; /* Ambiguous. */ 1214 } 1215 1216 /* We've matched something on this list. Move text pointer forward. */ 1217 1218 *text += len; 1219 1220 if (found->cmd_pointer) 1221 { 1222 /* We drop the alias (abbreviation) in favor of the command it is 1223 pointing to. If the alias is deprecated, though, we need to 1224 warn the user about it before we drop it. Note that while we 1225 are warning about the alias, we may also warn about the command 1226 itself and we will adjust the appropriate DEPRECATED_WARN_USER 1227 flags */ 1228 1229 if (found->flags & DEPRECATED_WARN_USER) 1230 deprecated_cmd_warning (&line); 1231 found = found->cmd_pointer; 1232 } 1233 /* If we found a prefix command, keep looking. */ 1234 1235 if (found->prefixlist) 1236 { 1237 c = lookup_cmd_1 (text, *found->prefixlist, result_list, 1238 ignore_help_classes); 1239 if (!c) 1240 { 1241 /* Didn't find anything; this is as far as we got. */ 1242 if (result_list != NULL) 1243 *result_list = clist; 1244 return found; 1245 } 1246 else if (c == (struct cmd_list_element *) -1) 1247 { 1248 /* We've gotten this far properly, but the next step 1249 is ambiguous. We need to set the result list to the best 1250 we've found (if an inferior hasn't already set it). */ 1251 if (result_list != NULL) 1252 if (!*result_list) 1253 /* This used to say *result_list = *found->prefixlist 1254 If that was correct, need to modify the documentation 1255 at the top of this function to clarify what is supposed 1256 to be going on. */ 1257 *result_list = found; 1258 return c; 1259 } 1260 else 1261 { 1262 /* We matched! */ 1263 return c; 1264 } 1265 } 1266 else 1267 { 1268 if (result_list != NULL) 1269 *result_list = clist; 1270 return found; 1271 } 1272 } 1273 1274 /* All this hair to move the space to the front of cmdtype */ 1275 1276 static void 1277 undef_cmd_error (char *cmdtype, char *q) 1278 { 1279 error (_("Undefined %scommand: \"%s\". Try \"help%s%.*s\"."), 1280 cmdtype, 1281 q, 1282 *cmdtype ? " " : "", 1283 (int) strlen (cmdtype) - 1, 1284 cmdtype); 1285 } 1286 1287 /* Look up the contents of *LINE as a command in the command list LIST. 1288 LIST is a chain of struct cmd_list_element's. 1289 If it is found, return the struct cmd_list_element for that command 1290 and update *LINE to point after the command name, at the first argument. 1291 If not found, call error if ALLOW_UNKNOWN is zero 1292 otherwise (or if error returns) return zero. 1293 Call error if specified command is ambiguous, 1294 unless ALLOW_UNKNOWN is negative. 1295 CMDTYPE precedes the word "command" in the error message. 1296 1297 If INGNORE_HELP_CLASSES is nonzero, ignore any command list 1298 elements which are actually help classes rather than commands (i.e. 1299 the function field of the struct cmd_list_element is 0). */ 1300 1301 struct cmd_list_element * 1302 lookup_cmd (char **line, struct cmd_list_element *list, char *cmdtype, 1303 int allow_unknown, int ignore_help_classes) 1304 { 1305 struct cmd_list_element *last_list = 0; 1306 struct cmd_list_element *c; 1307 1308 /* Note: Do not remove trailing whitespace here because this 1309 would be wrong for complete_command. Jim Kingdon */ 1310 1311 if (!*line) 1312 error (_("Lack of needed %scommand"), cmdtype); 1313 1314 c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes); 1315 1316 if (!c) 1317 { 1318 if (!allow_unknown) 1319 { 1320 char *q; 1321 int len = find_command_name_length (*line); 1322 1323 q = (char *) alloca (len + 1); 1324 strncpy (q, *line, len); 1325 q[len] = '\0'; 1326 undef_cmd_error (cmdtype, q); 1327 } 1328 else 1329 return 0; 1330 } 1331 else if (c == (struct cmd_list_element *) -1) 1332 { 1333 /* Ambigous. Local values should be off prefixlist or called 1334 values. */ 1335 int local_allow_unknown = (last_list ? last_list->allow_unknown : 1336 allow_unknown); 1337 char *local_cmdtype = last_list ? last_list->prefixname : cmdtype; 1338 struct cmd_list_element *local_list = 1339 (last_list ? *(last_list->prefixlist) : list); 1340 1341 if (local_allow_unknown < 0) 1342 { 1343 if (last_list) 1344 return last_list; /* Found something. */ 1345 else 1346 return 0; /* Found nothing. */ 1347 } 1348 else 1349 { 1350 /* Report as error. */ 1351 int amb_len; 1352 char ambbuf[100]; 1353 1354 for (amb_len = 0; 1355 ((*line)[amb_len] && (*line)[amb_len] != ' ' 1356 && (*line)[amb_len] != '\t'); 1357 amb_len++) 1358 ; 1359 1360 ambbuf[0] = 0; 1361 for (c = local_list; c; c = c->next) 1362 if (!strncmp (*line, c->name, amb_len)) 1363 { 1364 if (strlen (ambbuf) + strlen (c->name) + 6 < (int) sizeof ambbuf) 1365 { 1366 if (strlen (ambbuf)) 1367 strcat (ambbuf, ", "); 1368 strcat (ambbuf, c->name); 1369 } 1370 else 1371 { 1372 strcat (ambbuf, ".."); 1373 break; 1374 } 1375 } 1376 error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype, 1377 *line, ambbuf); 1378 return 0; /* lint */ 1379 } 1380 } 1381 else 1382 { 1383 /* We've got something. It may still not be what the caller 1384 wants (if this command *needs* a subcommand). */ 1385 while (**line == ' ' || **line == '\t') 1386 (*line)++; 1387 1388 if (c->prefixlist && **line && !c->allow_unknown) 1389 undef_cmd_error (c->prefixname, *line); 1390 1391 /* Seems to be what he wants. Return it. */ 1392 return c; 1393 } 1394 return 0; 1395 } 1396 1397 /* We are here presumably because an alias or command in *TEXT is 1398 deprecated and a warning message should be generated. This function 1399 decodes *TEXT and potentially generates a warning message as outlined 1400 below. 1401 1402 Example for 'set endian big' which has a fictitious alias 'seb'. 1403 1404 If alias wasn't used in *TEXT, and the command is deprecated: 1405 "warning: 'set endian big' is deprecated." 1406 1407 If alias was used, and only the alias is deprecated: 1408 "warning: 'seb' an alias for the command 'set endian big' is deprecated." 1409 1410 If alias was used and command is deprecated (regardless of whether the 1411 alias itself is deprecated: 1412 1413 "warning: 'set endian big' (seb) is deprecated." 1414 1415 After the message has been sent, clear the appropriate flags in the 1416 command and/or the alias so the user is no longer bothered. 1417 1418 */ 1419 void 1420 deprecated_cmd_warning (char **text) 1421 { 1422 struct cmd_list_element *alias = NULL; 1423 struct cmd_list_element *prefix_cmd = NULL; 1424 struct cmd_list_element *cmd = NULL; 1425 struct cmd_list_element *c; 1426 char *type; 1427 1428 if (!lookup_cmd_composition (*text, &alias, &prefix_cmd, &cmd)) 1429 /* return if text doesn't evaluate to a command */ 1430 return; 1431 1432 if (!((alias ? (alias->flags & DEPRECATED_WARN_USER) : 0) 1433 || (cmd->flags & DEPRECATED_WARN_USER) ) ) 1434 /* return if nothing is deprecated */ 1435 return; 1436 1437 printf_filtered ("Warning:"); 1438 1439 if (alias && !(cmd->flags & CMD_DEPRECATED)) 1440 printf_filtered (" '%s', an alias for the", alias->name); 1441 1442 printf_filtered (" command '"); 1443 1444 if (prefix_cmd) 1445 printf_filtered ("%s", prefix_cmd->prefixname); 1446 1447 printf_filtered ("%s", cmd->name); 1448 1449 if (alias && (cmd->flags & CMD_DEPRECATED)) 1450 printf_filtered ("' (%s) is deprecated.\n", alias->name); 1451 else 1452 printf_filtered ("' is deprecated.\n"); 1453 1454 1455 /* if it is only the alias that is deprecated, we want to indicate the 1456 new alias, otherwise we'll indicate the new command */ 1457 1458 if (alias && !(cmd->flags & CMD_DEPRECATED)) 1459 { 1460 if (alias->replacement) 1461 printf_filtered ("Use '%s'.\n\n", alias->replacement); 1462 else 1463 printf_filtered ("No alternative known.\n\n"); 1464 } 1465 else 1466 { 1467 if (cmd->replacement) 1468 printf_filtered ("Use '%s'.\n\n", cmd->replacement); 1469 else 1470 printf_filtered ("No alternative known.\n\n"); 1471 } 1472 1473 /* We've warned you, now we'll keep quiet */ 1474 if (alias) 1475 alias->flags &= ~DEPRECATED_WARN_USER; 1476 1477 cmd->flags &= ~DEPRECATED_WARN_USER; 1478 } 1479 1480 1481 1482 /* Look up the contents of LINE as a command in the command list 'cmdlist'. 1483 Return 1 on success, 0 on failure. 1484 1485 If LINE refers to an alias, *alias will point to that alias. 1486 1487 If LINE is a postfix command (i.e. one that is preceeded by a prefix 1488 command) set *prefix_cmd. 1489 1490 Set *cmd to point to the command LINE indicates. 1491 1492 If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not 1493 exist, they are NULL when we return. 1494 1495 */ 1496 int 1497 lookup_cmd_composition (char *text, 1498 struct cmd_list_element **alias, 1499 struct cmd_list_element **prefix_cmd, 1500 struct cmd_list_element **cmd) 1501 { 1502 char *command; 1503 int len, tmp, nfound; 1504 struct cmd_list_element *cur_list; 1505 struct cmd_list_element *prev_cmd; 1506 *alias = NULL; 1507 *prefix_cmd = NULL; 1508 *cmd = NULL; 1509 1510 cur_list = cmdlist; 1511 1512 while (1) 1513 { 1514 /* Go through as many command lists as we need to 1515 to find the command TEXT refers to. */ 1516 1517 prev_cmd = *cmd; 1518 1519 while (*text == ' ' || *text == '\t') 1520 (text)++; 1521 1522 /* Identify the name of the command. */ 1523 len = find_command_name_length (text); 1524 1525 /* If nothing but whitespace, return. */ 1526 if (len == 0) 1527 return 0; 1528 1529 /* text is the start of the first command word to lookup (and 1530 it's length is len). We copy this into a local temporary */ 1531 1532 command = (char *) alloca (len + 1); 1533 memcpy (command, text, len); 1534 command[len] = '\0'; 1535 1536 /* Look it up. */ 1537 *cmd = 0; 1538 nfound = 0; 1539 *cmd = find_cmd (command, len, cur_list, 1, &nfound); 1540 1541 /* We didn't find the command in the entered case, so lower case it 1542 and search again. 1543 */ 1544 if (!*cmd || nfound == 0) 1545 { 1546 for (tmp = 0; tmp < len; tmp++) 1547 { 1548 char x = command[tmp]; 1549 command[tmp] = isupper (x) ? tolower (x) : x; 1550 } 1551 *cmd = find_cmd (command, len, cur_list, 1, &nfound); 1552 } 1553 1554 if (*cmd == (struct cmd_list_element *) -1) 1555 { 1556 return 0; /* ambiguous */ 1557 } 1558 1559 if (*cmd == NULL) 1560 return 0; /* nothing found */ 1561 else 1562 { 1563 if ((*cmd)->cmd_pointer) 1564 { 1565 /* cmd was actually an alias, we note that an alias was used 1566 (by assigning *alais) and we set *cmd. 1567 */ 1568 *alias = *cmd; 1569 *cmd = (*cmd)->cmd_pointer; 1570 } 1571 *prefix_cmd = prev_cmd; 1572 } 1573 if ((*cmd)->prefixlist) 1574 cur_list = *(*cmd)->prefixlist; 1575 else 1576 return 1; 1577 1578 text += len; 1579 } 1580 } 1581 1582 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */ 1583 1584 /* Return a vector of char pointers which point to the different 1585 possible completions in LIST of TEXT. 1586 1587 WORD points in the same buffer as TEXT, and completions should be 1588 returned relative to this position. For example, suppose TEXT is "foo" 1589 and we want to complete to "foobar". If WORD is "oo", return 1590 "oobar"; if WORD is "baz/foo", return "baz/foobar". */ 1591 1592 char ** 1593 complete_on_cmdlist (struct cmd_list_element *list, char *text, char *word) 1594 { 1595 struct cmd_list_element *ptr; 1596 char **matchlist; 1597 int sizeof_matchlist; 1598 int matches; 1599 int textlen = strlen (text); 1600 1601 sizeof_matchlist = 10; 1602 matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *)); 1603 matches = 0; 1604 1605 for (ptr = list; ptr; ptr = ptr->next) 1606 if (!strncmp (ptr->name, text, textlen) 1607 && !ptr->abbrev_flag 1608 && (ptr->func 1609 || ptr->prefixlist)) 1610 { 1611 if (matches == sizeof_matchlist) 1612 { 1613 sizeof_matchlist *= 2; 1614 matchlist = (char **) xrealloc ((char *) matchlist, 1615 (sizeof_matchlist 1616 * sizeof (char *))); 1617 } 1618 1619 matchlist[matches] = (char *) 1620 xmalloc (strlen (word) + strlen (ptr->name) + 1); 1621 if (word == text) 1622 strcpy (matchlist[matches], ptr->name); 1623 else if (word > text) 1624 { 1625 /* Return some portion of ptr->name. */ 1626 strcpy (matchlist[matches], ptr->name + (word - text)); 1627 } 1628 else 1629 { 1630 /* Return some of text plus ptr->name. */ 1631 strncpy (matchlist[matches], word, text - word); 1632 matchlist[matches][text - word] = '\0'; 1633 strcat (matchlist[matches], ptr->name); 1634 } 1635 ++matches; 1636 } 1637 1638 if (matches == 0) 1639 { 1640 xfree (matchlist); 1641 matchlist = 0; 1642 } 1643 else 1644 { 1645 matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1) 1646 * sizeof (char *))); 1647 matchlist[matches] = (char *) 0; 1648 } 1649 1650 return matchlist; 1651 } 1652 1653 /* Helper function for SYMBOL_COMPLETION_FUNCTION. */ 1654 1655 /* Return a vector of char pointers which point to the different 1656 possible completions in CMD of TEXT. 1657 1658 WORD points in the same buffer as TEXT, and completions should be 1659 returned relative to this position. For example, suppose TEXT is "foo" 1660 and we want to complete to "foobar". If WORD is "oo", return 1661 "oobar"; if WORD is "baz/foo", return "baz/foobar". */ 1662 1663 char ** 1664 complete_on_enum (const char *enumlist[], 1665 char *text, 1666 char *word) 1667 { 1668 char **matchlist; 1669 int sizeof_matchlist; 1670 int matches; 1671 int textlen = strlen (text); 1672 int i; 1673 const char *name; 1674 1675 sizeof_matchlist = 10; 1676 matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *)); 1677 matches = 0; 1678 1679 for (i = 0; (name = enumlist[i]) != NULL; i++) 1680 if (strncmp (name, text, textlen) == 0) 1681 { 1682 if (matches == sizeof_matchlist) 1683 { 1684 sizeof_matchlist *= 2; 1685 matchlist = (char **) xrealloc ((char *) matchlist, 1686 (sizeof_matchlist 1687 * sizeof (char *))); 1688 } 1689 1690 matchlist[matches] = (char *) 1691 xmalloc (strlen (word) + strlen (name) + 1); 1692 if (word == text) 1693 strcpy (matchlist[matches], name); 1694 else if (word > text) 1695 { 1696 /* Return some portion of name. */ 1697 strcpy (matchlist[matches], name + (word - text)); 1698 } 1699 else 1700 { 1701 /* Return some of text plus name. */ 1702 strncpy (matchlist[matches], word, text - word); 1703 matchlist[matches][text - word] = '\0'; 1704 strcat (matchlist[matches], name); 1705 } 1706 ++matches; 1707 } 1708 1709 if (matches == 0) 1710 { 1711 xfree (matchlist); 1712 matchlist = 0; 1713 } 1714 else 1715 { 1716 matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1) 1717 * sizeof (char *))); 1718 matchlist[matches] = (char *) 0; 1719 } 1720 1721 return matchlist; 1722 } 1723 1724 1725 /* check function pointer */ 1726 int 1727 cmd_func_p (struct cmd_list_element *cmd) 1728 { 1729 return (cmd->func != NULL); 1730 } 1731 1732 1733 /* call the command function */ 1734 void 1735 cmd_func (struct cmd_list_element *cmd, char *args, int from_tty) 1736 { 1737 if (cmd_func_p (cmd)) 1738 (*cmd->func) (cmd, args, from_tty); 1739 else 1740 error (_("Invalid command")); 1741 } 1742