From mboxrd@z Thu Jan 1 00:00:00 1970 From: David Whedon To: gdb-patches@sourceware.cygnus.com Subject: [REPOST #2] patch: command deprecator Date: Tue, 29 Feb 2000 11:46:00 -0000 Message-ID: X-SW-Source: 2000-02/msg00083.html Message-ID: <20000229114600.p130IlozKFj0kBx4mvWFR86JfaNl0ZKTfgrVTpJBZ84@z> After working through some good suggestion by Elena, we have try number 2. Let me know if anything is awry. David 1999-02-22 David Whedon * top.c (execute_command): checks all commands beore executing to see if the user needs to be warned that the command is deprecated, warns user if appropriate. (add_info), (add_info_alias), (add_com) , (add_com_alias): changed return values from void to struct cmd_list_element *. * command.c (lookup_cmd_1): check aliases before following link in case user needs to be warned about a deprecated alias. (deprecate_cmd): new exported function for command deprecation, sets flags and posibly a replacement string. (deprecated_cmd_warning): new exported funciton to warn user about a deprecated command. (lookup_cmd_composition): new exported function that determines alias, prefix_command, and cmd based on a string. This is useful is we want to full name of a command. * command.h : added prototypes for deprecate_cmd, deprecated_warn_user and lookup_cmd_composition, added flags to the cmd_list_element structure, changed return values for add_com_* and add_info_* from void to cmd_list_element. * maint.c : (maintenance_deprecate): new function to deprecate a command. This exists only so that the testsuite can deprecate commands at runtime and check the warning behavior. (maintenance_undeprecate) : new function, drops deprecated flags. (maintenance_do_deprecate): actually does the (un)deprecation. (initialize_maint_cmds): added the above new deprecate commands. * gdbint.texinfo : added paragraphs about command deprecation. * commands.exp : added command deprecator tests. Native configuration is i686-pc-linux-gnu before: === gdb Summary === # of expected passes 6356 # of unexpected failures 13 # of expected failures 200 # of unresolved testcases 3 /mnt/gordian/src/gdb-cvs/cur_cvs/b-native/gdb/testsuite/../../gdb/gdb version 20000204 -nx after: === gdb Summary === # of expected passes 6368 # of unexpected failures 13 # of expected failures 200 # of unresolved testcases 3 /mnt/gordian/src/gdb-cvs/cur_cvs/b-native/gdb/testsuite/../../gdb/gdb version 20000204 -nx Index: gdb/command.c =================================================================== RCS file: /cvs/src/src/gdb/command.c,v retrieving revision 1.2 diff -c -3 -p -r1.2 command.c *** command.c 2000/02/09 08:52:45 1.2 --- command.c 2000/02/29 08:55:25 *************** add_cmd (name, class, fun, doc, list) *** 108,113 **** --- 108,115 ---- c->class = class; c->function.cfunc = fun; c->doc = doc; + c->flags = 0; + c->replacement = NULL; c->hook = NULL; c->prefixlist = NULL; c->prefixname = NULL; *************** add_cmd (name, class, fun, doc, list) *** 125,130 **** --- 127,159 ---- return c; } + + /* Deprecates a command CMD. + REPLACEMENT is the name of the command which should be used in place + of this command, or NULL if no such command exists. + + This function does not check to see if command REPLACEMENT exists + since gdb may not have gotten around to adding REPLACEMENT when this + function is called. + + Returns a pointer to the deprecated command. */ + + struct cmd_list_element * + deprecate_cmd (cmd, replacement) + struct cmd_list_element *cmd; + char *replacement; + { + cmd->flags |= (CMD_DEPRECATED | DEPRECATED_WARN_USER); + + if (replacement != NULL) + cmd->replacement = replacement; + else + cmd->replacement = NULL; + + return cmd; + } + + /* Same as above, except that the abbrev_flag is set. */ #if 0 /* Currently unused */ *************** lookup_cmd_1 (text, clist, result_list, *** 645,650 **** --- 674,680 ---- char *p, *command; int len, tmp, nfound; struct cmd_list_element *found, *c; + char *line = *text; while (**text == ' ' || **text == '\t') (*text)++; *************** lookup_cmd_1 (text, clist, result_list, *** 714,724 **** *text = p; - /* If this was an abbreviation, use the base command instead. */ - if (found->cmd_pointer) ! found = found->cmd_pointer; ! /* If we found a prefix command, keep looking. */ if (found->prefixlist) --- 744,762 ---- *text = p; if (found->cmd_pointer) ! { ! /* We drop the alias (abbreviation) in favor of the command it is ! pointing to. If the alias is deprecated, though, we need to ! warn the user about it before we drop it. Note that while we ! are warning about the alias, we may also warn about the command ! itself and we will adjust the appropriate DEPRECATED_WARN_USER ! flags */ ! ! if (found->flags & DEPRECATED_WARN_USER) ! deprecated_cmd_warning (&line); ! found = found->cmd_pointer; ! } /* If we found a prefix command, keep looking. */ if (found->prefixlist) *************** lookup_cmd (line, list, cmdtype, allow_u *** 802,808 **** #if 0 /* This is wrong for complete_command. */ char *ptr = (*line) + strlen (*line) - 1; - /* Clear off trailing whitespace. */ while (ptr >= *line && (*ptr == ' ' || *ptr == '\t')) ptr--; --- 840,845 ---- *************** lookup_cmd (line, list, cmdtype, allow_u *** 896,901 **** --- 935,1142 ---- } return 0; } + + /* We are here presumably because an alias or command in *TEXT is + deprecated and a warning message should be generated. This function + decodes *TEXT and potentially generates a warning message as outlined + below. + + Example for 'set endian big' which has a fictitious alias 'seb'. + + If alias wasn't used in *TEXT, and the command is deprecated: + "warning: 'set endian big' is deprecated." + + If alias was used, and only the alias is deprecated: + "warning: 'seb' an alias for the command 'set endian big' is deprecated." + + If alias was used and command is deprecated (regardless of whether the + alias itself is deprecated: + + "warning: 'set endian big' (seb) is deprecated." + + After the message has been sent, clear the appropriate flags in the + command and/or the alias so the user is no longer bothered. + + */ + void + deprecated_cmd_warning (char **text) + { + struct cmd_list_element *alias = NULL; + struct cmd_list_element *prefix_cmd = NULL; + struct cmd_list_element *cmd = NULL; + struct cmd_list_element *c; + char *type; + + if (!lookup_cmd_composition (*text, &alias, &prefix_cmd, &cmd)) + /* return if text doesn't evaluate to a command */ + return; + + if (!((alias ? (alias->flags & DEPRECATED_WARN_USER) : 0) + || (cmd->flags & DEPRECATED_WARN_USER) ) ) + /* return if nothing is deprecated */ + return; + + printf_filtered ("Warning:"); + + if (alias && !(cmd->flags & CMD_DEPRECATED)) + printf_filtered (" '%s', an alias for the", alias->name); + + printf_filtered (" command '"); + + if (prefix_cmd) + printf_filtered ("%s", prefix_cmd->prefixname); + + printf_filtered ("%s", cmd->name); + + if (alias && (cmd->flags & CMD_DEPRECATED)) + printf_filtered ("' (%s) is deprecated.\n", alias->name); + else + printf_filtered ("' is deprecated.\n"); + + + /* if it is only the alias that is deprecated, we want to indicate the + new alias, otherwise we'll indicate the new command */ + + if (alias && !(cmd->flags & CMD_DEPRECATED)) + { + if (alias->replacement) + printf_filtered ("Use '%s'.\n\n", alias->replacement); + else + printf_filtered ("No alternative known.\n\n"); + } + else + { + if (cmd->replacement) + printf_filtered ("Use '%s'.\n\n", cmd->replacement); + else + printf_filtered ("No alternative known.\n\n"); + } + + /* We've warned you, now we'll keep quiet */ + if (alias) + alias->flags &= ~DEPRECATED_WARN_USER; + + cmd->flags &= ~DEPRECATED_WARN_USER; + } + + + + /* Look up the contents of LINE as a command in the command list 'cmdlist'. + Return 1 on success, 0 on failure. + + If LINE refers to an alias, *alias will point to that alias. + + If LINE is a postfix command (i.e. one that is preceeded by a prefix + command) set *prefix_cmd. + + Set *cmd to point to the command LINE indicates. + + If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not + exist, they are NULL when we return. + + */ + int + lookup_cmd_composition (char *text, + struct cmd_list_element **alias, + struct cmd_list_element **prefix_cmd, + struct cmd_list_element **cmd) + { + char *p, *command; + int len, tmp, nfound; + struct cmd_list_element *cur_list; + struct cmd_list_element *prev_cmd; + *alias = NULL; + *prefix_cmd = NULL; + *cmd = NULL; + + cur_list = cmdlist; + + while (1) + { + /* Go through as many command lists as we need to + to find the command TEXT refers to. */ + + prev_cmd = *cmd; + + while (*text == ' ' || *text == '\t') + (text)++; + + /* Treating underscores as part of command words is important + so that "set args_foo()" doesn't get interpreted as + "set args _foo()". */ + for (p = text; + *p && (isalnum (*p) || *p == '-' || *p == '_' || + (tui_version && + (*p == '+' || *p == '<' || *p == '>' || *p == '$')) || + (xdb_commands && (*p == '!' || *p == '/' || *p == '?'))); + p++) + ; + + /* If nothing but whitespace, return. */ + if (p == text) + return 0; + + len = p - text; + + /* text and p now bracket the first command word to lookup (and + it's length is len). We copy this into a local temporary */ + + command = (char *) alloca (len + 1); + for (tmp = 0; tmp < len; tmp++) + { + char x = text[tmp]; + command[tmp] = x; + } + command[len] = '\0'; + + /* Look it up. */ + *cmd = 0; + nfound = 0; + *cmd = find_cmd (command, len, cur_list, 1, &nfound); + + /* We didn't find the command in the entered case, so lower case it + and search again. + */ + if (!*cmd || nfound == 0) + { + for (tmp = 0; tmp < len; tmp++) + { + char x = command[tmp]; + command[tmp] = isupper (x) ? tolower (x) : x; + } + *cmd = find_cmd (command, len, cur_list, 1, &nfound); + } + + if (*cmd == (struct cmd_list_element *) -1) + { + return 0; /* ambiguous */ + } + + if (*cmd == NULL) + return 0; /* nothing found */ + else + { + if ((*cmd)->cmd_pointer) + { + /* cmd was actually an alias, we note that an alias was used + (by assigning *alais) and we set *cmd. + */ + *alias = *cmd; + *cmd = (*cmd)->cmd_pointer; + } + *prefix_cmd = prev_cmd; + } + if ((*cmd)->prefixlist) + cur_list = *(*cmd)->prefixlist; + else + return 1; + + text = p; + } + } + + + #if 0 /* Look up the contents of *LINE as a command in the command list LIST. Index: gdb/command.h =================================================================== RCS file: /cvs/src/src/gdb/command.h,v retrieving revision 1.1.1.4 diff -c -3 -p -r1.1.1.4 command.h *** command.h 2000/02/02 00:21:05 1.1.1.4 --- command.h 2000/02/29 08:55:25 *************** var_types; *** 82,87 **** --- 82,96 ---- /* This structure records one command'd definition. */ + + /* This flag is used by the code executing commands to warn the user + the first time a deprecated command is used, see the 'flags' field in + the following struct. + */ + #define CMD_DEPRECATED 0x1 + #define DEPRECATED_WARN_USER 0x2 + #define MALLOCED_REPLACEMENT 0x4 + struct cmd_list_element { /* Points to next command in this list. */ *************** struct cmd_list_element *** 115,120 **** --- 124,154 ---- Entire string should also end with a period, not a newline. */ char *doc; + /* flags : a bitfield + + bit 0: (LSB) CMD_DEPRECATED, when 1 indicated that this command + is deprecated. It may be removed from gdb's command set in the + future. + + bit 1: DEPRECATED_WARN_USER, the user needs to be warned that + this is a deprecated command. The user should only be warned + the first time a command is used. + + bit 2: MALLOCED_REPLACEMENT, when functions are deprecated at + compile time (this is the way it should, in general, be done) + the memory comtaining the replacement string is statically + allocated. In some cases it makes sense to deprecate commands + at runtime (the testsuite is one example). In this case the + memory for replacement is malloc'ed. When a command is + undeprecated or re-deprecated at runtime we don't want to risk + calling free on statically allocated memory, so we check this + flag. + */ + int flags; + + /* if this command is deprecated, this is the replacement name */ + char *replacement; + /* Hook for another command to be executed before this command. */ struct cmd_list_element *hook; *************** extern struct cmd_list_element * *** 208,225 **** lookup_cmd_1 PARAMS ((char **, struct cmd_list_element *, struct cmd_list_element **, int)); extern void ! add_com PARAMS ((char *, enum command_class, void (*fun) (char *, int), char *)); ! extern void ! add_com_alias PARAMS ((char *, char *, enum command_class, int)); ! extern void ! add_info PARAMS ((char *, void (*fun) (char *, int), char *)); ! extern void ! add_info_alias PARAMS ((char *, char *, int)); extern char ** complete_on_cmdlist PARAMS ((struct cmd_list_element *, char *, char *)); --- 242,271 ---- lookup_cmd_1 PARAMS ((char **, struct cmd_list_element *, struct cmd_list_element **, int)); + extern struct cmd_list_element * + deprecate_cmd (struct cmd_list_element *, char * ); + extern void ! deprecated_cmd_warning (char **); ! ! extern int ! lookup_cmd_composition (char *text, ! struct cmd_list_element **alias, ! struct cmd_list_element **prefix_cmd, ! struct cmd_list_element **cmd); ! ! extern struct cmd_list_element * ! add_com PARAMS ((char *, enum command_class, void (*fun) (char *, int), char *)); ! extern struct cmd_list_element * ! add_com_alias PARAMS ((char *, char *, enum command_class, int)); ! extern struct cmd_list_element * ! add_info PARAMS ((char *, void (*fun) (char *, int), char *)); ! extern struct cmd_list_element * ! add_info_alias PARAMS ((char *, char *, int)); extern char ** complete_on_cmdlist PARAMS ((struct cmd_list_element *, char *, char *)); Index: gdb/maint.c =================================================================== RCS file: /cvs/src/src/gdb/maint.c,v retrieving revision 1.1.1.7 diff -c -3 -p -r1.1.1.7 maint.c *** maint.c 1999/09/08 23:59:19 1.1.1.7 --- maint.c 2000/02/29 08:55:25 *************** maintenance_translate_address (arg, from *** 358,363 **** --- 358,476 ---- return; } + + /* When a comamnd is deprecated the user will be warned the first time + the command is used. If possible, a replacement will be offered. */ + + static void + maintenance_deprecate (char *args, int from_tty) + { + if (args == NULL || *args == '\0') + { + printf_unfiltered ("\"maintenance deprecate\" takes an argument, \n\ + the command you want to deprecate, and optionally the replacement command \n\ + enclosed in quotes.\n"); + } + + maintenance_do_deprecate (args, 1); + + } + + + static void + maintenance_undeprecate (char *args, int from_tty) + { + if (args == NULL || *args == '\0') + { + printf_unfiltered ("\"maintenance undeprecate\" takes an argument, \n\ + the command you want to undeprecate.\n"); + } + + maintenance_do_deprecate (args, 0); + + } + + /* + You really shouldn't be using this. It is just for the testsuite. + Rather, you should use deprecate_cmd() when the command is created + in _initialize_blah(). + + This function deprecates a command and optionally assigns it a + replacement. + */ + + static void maintenance_do_deprecate(char *text, int deprecate){ + + struct cmd_list_element *alias=NULL; + struct cmd_list_element *prefix_cmd=NULL; + struct cmd_list_element *cmd=NULL; + + char *start_ptr=NULL; + char *end_ptr=NULL; + int len; + char *replacement=NULL; + + + if (!lookup_cmd_composition (text, &alias, &prefix_cmd, &cmd)){ + printf_filtered ("Can't find command '%s' to deprecate.\n", text); + return; + } + + if (deprecate) + { + /* look for a replacement command */ + if (start_ptr = strchr (text, '\"')) + { + start_ptr++; + if(end_ptr = strrchr (start_ptr, '\"')) + { + len = end_ptr-start_ptr; + start_ptr[len]='\0'; + replacement = xstrdup (start_ptr); + } + } + } + + if (!start_ptr || !end_ptr) + replacement = NULL; + + + /* If they used an alias, we only want to deprecate the alias. + + Note the MALLOCED_REPLACEMENT test. If the command's replacement + string was allocated at compile time we don't want to free the + memory. + */ + if (alias) + { + + if (alias->flags & MALLOCED_REPLACEMENT) + free (alias->replacement); + + if (deprecate) + alias->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED); + else + alias->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED); + alias->replacement=replacement; + alias->flags |= MALLOCED_REPLACEMENT; + return; + } + else if (cmd) + { + if (cmd->flags & MALLOCED_REPLACEMENT) + free (cmd->replacement); + + if (deprecate) + cmd->flags |= (DEPRECATED_WARN_USER | CMD_DEPRECATED); + else + cmd->flags &= ~(DEPRECATED_WARN_USER | CMD_DEPRECATED); + cmd->replacement=replacement; + cmd->flags |= MALLOCED_REPLACEMENT; + return; + } + } + + void _initialize_maint_cmds () { *************** If a SOURCE file is specified, dump only *** 456,461 **** --- 569,587 ---- "Translate a section name and address to a symbol.", &maintenancelist); + add_cmd ("deprecate", class_maintenance, maintenance_deprecate, + "Deprecate a command. Note that this is just in here so the \n\ + testsuite can check the comamnd deprecator. You probably shouldn't use this,\n\ + rather you should use the C function deprecate_cmd(). If you decide you \n\ + want to use it: maintenance deprecate 'commandname' \"replacement\". The \n\ + replacement is optional.", &maintenancelist); + + add_cmd ("undeprecate", class_maintenance, maintenance_undeprecate, + "Undeprecate a command. Note that this is just in here so the \n\ + testsuite can check the comamnd deprecator. You probably shouldn't use this,\n\ + If you decide you want to use it: maintenance undeprecate 'commandname'", + &maintenancelist); + add_show_from_set ( add_set_cmd ("watchdog", class_maintenance, var_zinteger, (char *) &watchdog, "Set watchdog timer.\n\ Index: gdb/top.c =================================================================== RCS file: /cvs/src/src/gdb/top.c,v retrieving revision 1.4 diff -c -3 -p -r1.4 top.c *** top.c 2000/02/24 00:04:03 1.4 --- top.c 2000/02/29 08:55:26 *************** execute_command (p, from_tty) *** 1474,1479 **** --- 1474,1480 ---- register struct cmd_list_element *c; register enum language flang; static int warned = 0; + char *line; /* FIXME: These should really be in an appropriate header file */ extern void serial_log_command PARAMS ((const char *)); *************** execute_command (p, from_tty) *** 1494,1500 **** if (*p) { char *arg; ! c = lookup_cmd (&p, cmdlist, "", 0, 1); /* If the target is running, we allow only a limited set of --- 1495,1502 ---- if (*p) { char *arg; ! line = p; ! c = lookup_cmd (&p, cmdlist, "", 0, 1); /* If the target is running, we allow only a limited set of *************** execute_command (p, from_tty) *** 1517,1527 **** p--; *(p + 1) = '\0'; } ! /* If this command has been hooked, run the hook first. */ if (c->hook) execute_user_command (c->hook, (char *) 0); if (c->class == class_user) execute_user_command (c, arg); else if (c->type == set_cmd || c->type == show_cmd) --- 1519,1532 ---- p--; *(p + 1) = '\0'; } ! /* If this command has been hooked, run the hook first. */ if (c->hook) execute_user_command (c->hook, (char *) 0); + if (c->flags & DEPRECATED_WARN_USER) + deprecated_cmd_warning (&line); + if (c->class == class_user) execute_user_command (c, arg); else if (c->type == set_cmd || c->type == show_cmd) *************** free_command_lines (lptr) *** 2892,2915 **** /* Add an element to the list of info subcommands. */ ! void add_info (name, fun, doc) char *name; void (*fun) PARAMS ((char *, int)); char *doc; { ! add_cmd (name, no_class, fun, doc, &infolist); } /* Add an alias to the list of info subcommands. */ ! void add_info_alias (name, oldname, abbrev_flag) char *name; char *oldname; int abbrev_flag; { ! add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist); } /* The "info" command is defined as a prefix, with allow_unknown = 0. --- 2897,2920 ---- /* Add an element to the list of info subcommands. */ ! struct cmd_list_element * add_info (name, fun, doc) char *name; void (*fun) PARAMS ((char *, int)); char *doc; { ! return add_cmd (name, no_class, fun, doc, &infolist); } /* Add an alias to the list of info subcommands. */ ! struct cmd_list_element * add_info_alias (name, oldname, abbrev_flag) char *name; char *oldname; int abbrev_flag; { ! return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist); } /* The "info" command is defined as a prefix, with allow_unknown = 0. *************** show_command (arg, from_tty) *** 2965,2990 **** /* Add an element to the list of commands. */ ! void add_com (name, class, fun, doc) char *name; enum command_class class; void (*fun) PARAMS ((char *, int)); char *doc; { ! add_cmd (name, class, fun, doc, &cmdlist); } /* Add an alias or abbreviation command to the list of commands. */ ! void add_com_alias (name, oldname, class, abbrev_flag) char *name; char *oldname; enum command_class class; int abbrev_flag; { ! add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist); } void --- 2970,2995 ---- /* Add an element to the list of commands. */ ! struct cmd_list_element * add_com (name, class, fun, doc) char *name; enum command_class class; void (*fun) PARAMS ((char *, int)); char *doc; { ! return add_cmd (name, class, fun, doc, &cmdlist); } /* Add an alias or abbreviation command to the list of commands. */ ! struct cmd_list_element * add_com_alias (name, oldname, class, abbrev_flag) char *name; char *oldname; enum command_class class; int abbrev_flag; { ! return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist); } void Index: gdb/doc/gdbint.texinfo =================================================================== RCS file: /cvs/src/src/gdb/doc/gdbint.texinfo,v retrieving revision 1.3 diff -c -3 -p -r1.3 gdbint.texinfo *** gdbint.texinfo 2000/02/23 19:45:45 1.3 --- gdbint.texinfo 2000/02/29 08:55:27 *************** to the @code{set_thread_cmd_list}. *** 332,339 **** To add commands in general, use @code{add_cmd}. @code{add_com} adds to the main command list, and should be used for those commands. The usual ! place to add commands is in the @code{_initialize_@var{xyz}} routines at the ! ends of most source files. @section Console Printing --- 332,351 ---- To add commands in general, use @code{add_cmd}. @code{add_com} adds to the main command list, and should be used for those commands. The usual ! place to add commands is in the @code{_initialize_@var{xyz}} routines at ! the ends of most source files. ! ! Before removing commands from the command set it is a good idea to ! deprecate them for some time. Use @code{deprecate_cmd} on commands or ! aliases to set the deprecated flag. @code{deprecate_cmd} takes a ! @code{struct cmd_list_element} as it's first argument. You can use the ! return value from @code{add_com} or @code{add_cmd} to deprecate the ! command immediately after it is created. ! ! The first time a comamnd is used the user will be warned and offered a ! replacement (if one exists). Note that the replacement string passed to ! @code{deprecate_cmd} should be the full name of the command, i.e. the ! entire string the user should type at the command line. @section Console Printing Index: gdb/testsuite/gdb.base/commands.exp =================================================================== RCS file: /cvs/src/src/gdb/testsuite/gdb.base/commands.exp,v retrieving revision 1.1.1.5 diff -c -3 -p -r1.1.1.5 commands.exp *** commands.exp 1999/11/17 02:30:37 1.1.1.5 --- commands.exp 2000/02/29 08:55:27 *************** proc test_command_prompt_position {} { *** 375,380 **** --- 375,405 ---- } + + proc deprecated_command_test {} { + + + gdb_test "maintenance deprecate blah" "Can't find command.*" \ + "tried to deprecate non-existsing command" + + gdb_test "maintenance deprecate p \"new_p\"" "" + gdb_test "p 5" "Warning: 'p', an alias for the command 'print' is deprecated.*Use 'new_p'.*" "p deprecated warning, with replacement" + gdb_test "p 5" ".\[0-9\]* = 5.*" "Deprecated warning goes away" + + gdb_test "maintenance deprecate p \"new_p\"" "" + gdb_test "maintenance deprecate print \"new_print\"" "" + gdb_test "p 5" "Warning: command 'print' \\(p\\) is deprecated.*Use 'new_print'.*" "both alias and command are deprecated" + gdb_test "p 5" ".\[0-9\]* = 5.*" "Deprecated warning goes away" + + gdb_test "maintenance deprecate set endian big \"seb\" " "" "deprecate long comamnd" + gdb_test "set endian big" "Warning: command 'set endian big' is deprecated.*Use 'seb'.*" "long command deprecated" + + gdb_test "maintenance deprecate set endian big" "" "deprecate long comamnd" + gdb_test "set endian big" "Warning: command 'set endian big' is deprecated.*No alternative known.*" "long command deprecated with no alternative." + + } + + gdbvar_simple_if_test gdbvar_simple_while_test gdbvar_complex_if_while_test *************** breakpoint_command_test *** 387,392 **** --- 412,420 ---- user_defined_command_test watchpoint_command_test test_command_prompt_position + deprecated_command_test + +