gdb/
[platform/upstream/binutils.git] / gdb / cli / cli-decode.c
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 \f
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 \f
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 \f
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=1; /*Needed to avoid double printing*/
759   /* Walk through the commands */
760   for (c=commandlist;c;c=c->next)
761     {
762       if (c->name != NULL)
763         {
764           /* Try to match against the name*/
765           returnvalue=re_search(regex,c->name,strlen(c->name),0,strlen(c->name),NULL);
766           if (returnvalue >= 0)
767             {
768               print_help_for_command (c, prefix, 
769                                       0 /* don't recurse */, stream);
770             }
771         }
772       if (c->doc != NULL && returnvalue != 0)
773         {
774           /* Try to match against documentation */
775           if (re_search(regex,c->doc,strlen(c->doc),0,strlen(c->doc),NULL) >=0)
776             {
777               print_help_for_command (c, prefix, 
778                                       0 /* don't recurse */, stream);
779             }
780         }
781       /* Check if this command has subcommands */
782       if (c->prefixlist != NULL)
783         {
784           /* Recursively call ourselves on the subcommand list,
785              passing the right prefix in.
786           */
787           apropos_cmd (stream,*c->prefixlist,regex,c->prefixname);
788         }
789     }
790 }
791
792 /* This command really has to deal with two things:
793  *     1) I want documentation on *this string* (usually called by
794  * "help commandname").
795  *     2) I want documentation on *this list* (usually called by
796  * giving a command that requires subcommands.  Also called by saying
797  * just "help".)
798  *
799  *   I am going to split this into two seperate comamnds, help_cmd and
800  * help_list. 
801  */
802
803 void
804 help_cmd (char *command, struct ui_file *stream)
805 {
806   struct cmd_list_element *c;
807   extern struct cmd_list_element *cmdlist;
808
809   if (!command)
810     {
811       help_list (cmdlist, "", all_classes, stream);
812       return;
813     }
814
815   if (strcmp (command, "all") == 0)
816     {
817       help_all (stream);
818       return;
819     }
820
821   c = lookup_cmd (&command, cmdlist, "", 0, 0);
822
823   if (c == 0)
824     return;
825
826   /* There are three cases here.
827      If c->prefixlist is nonzero, we have a prefix command.
828      Print its documentation, then list its subcommands.
829
830      If c->func is non NULL, we really have a command.  Print its
831      documentation and return.
832
833      If c->func is NULL, we have a class name.  Print its
834      documentation (as if it were a command) and then set class to the
835      number of this class so that the commands in the class will be
836      listed.  */
837
838   fputs_filtered (c->doc, stream);
839   fputs_filtered ("\n", stream);
840
841   if (c->prefixlist == 0 && c->func != NULL)
842     return;
843   fprintf_filtered (stream, "\n");
844
845   /* If this is a prefix command, print it's subcommands */
846   if (c->prefixlist)
847     help_list (*c->prefixlist, c->prefixname, all_commands, stream);
848
849   /* If this is a class name, print all of the commands in the class */
850   if (c->func == NULL)
851     help_list (cmdlist, "", c->class, stream);
852
853   if (c->hook_pre || c->hook_post)
854     fprintf_filtered (stream,
855                       "\nThis command has a hook (or hooks) defined:\n");
856
857   if (c->hook_pre)
858     fprintf_filtered (stream,
859                       "\tThis command is run after  : %s (pre hook)\n",
860                     c->hook_pre->name);
861   if (c->hook_post)
862     fprintf_filtered (stream,
863                       "\tThis command is run before : %s (post hook)\n",
864                     c->hook_post->name);
865 }
866
867 /*
868  * Get a specific kind of help on a command list.
869  *
870  * LIST is the list.
871  * CMDTYPE is the prefix to use in the title string.
872  * CLASS is the class with which to list the nodes of this list (see
873  * documentation for help_cmd_list below),  As usual, ALL_COMMANDS for
874  * everything, ALL_CLASSES for just classes, and non-negative for only things
875  * in a specific class.
876  * and STREAM is the output stream on which to print things.
877  * If you call this routine with a class >= 0, it recurses.
878  */
879 void
880 help_list (struct cmd_list_element *list, char *cmdtype,
881            enum command_class class, struct ui_file *stream)
882 {
883   int len;
884   char *cmdtype1, *cmdtype2;
885
886   /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub"  */
887   len = strlen (cmdtype);
888   cmdtype1 = (char *) alloca (len + 1);
889   cmdtype1[0] = 0;
890   cmdtype2 = (char *) alloca (len + 4);
891   cmdtype2[0] = 0;
892   if (len)
893     {
894       cmdtype1[0] = ' ';
895       strncpy (cmdtype1 + 1, cmdtype, len - 1);
896       cmdtype1[len] = 0;
897       strncpy (cmdtype2, cmdtype, len - 1);
898       strcpy (cmdtype2 + len - 1, " sub");
899     }
900
901   if (class == all_classes)
902     fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
903   else
904     fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
905
906   help_cmd_list (list, class, cmdtype, (int) class >= 0, stream);
907
908   if (class == all_classes)
909     {
910       fprintf_filtered (stream, "\n\
911 Type \"help%s\" followed by a class name for a list of commands in ",
912                         cmdtype1);
913       wrap_here ("");
914       fprintf_filtered (stream, "that class.");
915
916       fprintf_filtered (stream, "\n\
917 Type \"help all\" for the list of all commands.");
918     }
919
920   fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
921                     cmdtype1, cmdtype2);
922   wrap_here ("");
923   fputs_filtered ("for ", stream);
924   wrap_here ("");
925   fputs_filtered ("full ", stream);
926   wrap_here ("");
927   fputs_filtered ("documentation.\n", stream);
928   fputs_filtered ("Type \"apropos word\" to search "
929                   "for commands related to \"word\".\n", stream);                   
930   fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
931                   stream);
932 }
933
934 static void
935 help_all (struct ui_file *stream)
936 {
937   struct cmd_list_element *c;
938   extern struct cmd_list_element *cmdlist;
939   int seen_unclassified = 0;
940
941   for (c = cmdlist; c; c = c->next)
942     {
943       if (c->abbrev_flag)
944         continue;
945       /* If this is a class name, print all of the commands in the class */
946
947       if (c->func == NULL)
948         {
949           fprintf_filtered (stream, "\nCommand class: %s\n\n", c->name);
950           help_cmd_list (cmdlist, c->class, "", 1, stream);
951         }
952     }
953
954   /* While it's expected that all commands are in some class,
955      as a safety measure, we'll print commands outside of any
956      class at the end.  */
957
958   for (c = cmdlist; c; c = c->next)
959     {
960       if (c->abbrev_flag)
961         continue;
962
963       if (c->class == no_class)
964         {
965           if (!seen_unclassified)
966             {
967               fprintf_filtered (stream, "\nUnclassified commands\n\n");
968               seen_unclassified = 1;
969             }
970           print_help_for_command (c, "", 1, stream);
971         }
972     }
973
974 }
975
976 /* Print only the first line of STR on STREAM.  */
977 void
978 print_doc_line (struct ui_file *stream, char *str)
979 {
980   static char *line_buffer = 0;
981   static int line_size;
982   char *p;
983
984   if (!line_buffer)
985     {
986       line_size = 80;
987       line_buffer = (char *) xmalloc (line_size);
988     }
989
990   p = str;
991   while (*p && *p != '\n' && *p != '.' && *p != ',')
992     p++;
993   if (p - str > line_size - 1)
994     {
995       line_size = p - str + 1;
996       xfree (line_buffer);
997       line_buffer = (char *) xmalloc (line_size);
998     }
999   strncpy (line_buffer, str, p - str);
1000   line_buffer[p - str] = '\0';
1001   if (islower (line_buffer[0]))
1002     line_buffer[0] = toupper (line_buffer[0]);
1003   ui_out_text (uiout, line_buffer);
1004 }
1005
1006 /* Print one-line help for command C.
1007    If RECURSE is non-zero, also print one-line descriptions
1008    of all prefixed subcommands. */
1009 static void
1010 print_help_for_command (struct cmd_list_element *c, char *prefix, int recurse,
1011                         struct ui_file *stream)
1012 {
1013   fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
1014   print_doc_line (stream, c->doc);
1015   fputs_filtered ("\n", stream);
1016   
1017   if (recurse
1018       && c->prefixlist != 0
1019       && c->abbrev_flag == 0)
1020     /* Subcommands of a prefix command typically have 'all_commands'
1021        as class.  If we pass CLASS to recursive invocation,
1022        most often we won't see anything. */
1023     help_cmd_list (*c->prefixlist, all_commands, c->prefixname, 1, stream);
1024 }
1025
1026 /*
1027  * Implement a help command on command list LIST.
1028  * RECURSE should be non-zero if this should be done recursively on
1029  * all sublists of LIST.
1030  * PREFIX is the prefix to print before each command name.
1031  * STREAM is the stream upon which the output should be written.
1032  * CLASS should be:
1033  *      A non-negative class number to list only commands in that
1034  * class.
1035  *      ALL_COMMANDS to list all commands in list.
1036  *      ALL_CLASSES  to list all classes in list.
1037  *
1038  *   Note that RECURSE will be active on *all* sublists, not just the
1039  * ones selected by the criteria above (ie. the selection mechanism
1040  * is at the low level, not the high-level).
1041  */
1042 void
1043 help_cmd_list (struct cmd_list_element *list, enum command_class class,
1044                char *prefix, int recurse, struct ui_file *stream)
1045 {
1046   struct cmd_list_element *c;
1047
1048   for (c = list; c; c = c->next)
1049     {      
1050       if (c->abbrev_flag == 0 &&
1051           (class == all_commands
1052            || (class == all_classes && c->func == NULL)
1053            || (class == c->class && c->func != NULL)))
1054         {
1055           print_help_for_command (c, prefix, recurse, stream);
1056         }
1057       else if (c->abbrev_flag == 0 && recurse
1058                && class == class_user && c->prefixlist != NULL)
1059         /* User-defined commands may be subcommands.  */
1060         help_cmd_list (*c->prefixlist, class, c->prefixname, recurse, stream);
1061     }
1062 }
1063 \f
1064
1065 /* Search the input clist for 'command'.  Return the command if
1066    found (or NULL if not), and return the number of commands
1067    found in nfound */
1068
1069 static struct cmd_list_element *
1070 find_cmd (char *command, int len, struct cmd_list_element *clist,
1071           int ignore_help_classes, int *nfound)
1072 {
1073   struct cmd_list_element *found, *c;
1074
1075   found = (struct cmd_list_element *) NULL;
1076   *nfound = 0;
1077   for (c = clist; c; c = c->next)
1078     if (!strncmp (command, c->name, len)
1079         && (!ignore_help_classes || c->func))
1080       {
1081         found = c;
1082         (*nfound)++;
1083         if (c->name[len] == '\0')
1084           {
1085             *nfound = 1;
1086             break;
1087           }
1088       }
1089   return found;
1090 }
1091
1092 static int
1093 find_command_name_length (const char *text)
1094 {
1095   const char *p = text;
1096
1097   /* Treating underscores as part of command words is important
1098      so that "set args_foo()" doesn't get interpreted as
1099      "set args _foo()".  */
1100   /* Some characters are only used for TUI specific commands. However, they
1101      are always allowed for the sake of consistency.
1102      The XDB compatibility characters are only allowed when using the right
1103      mode because they clash with other GDB commands - specifically '/' is
1104      used as a suffix for print, examine and display.
1105      Note that this is larger than the character set allowed when creating
1106      user-defined commands.  */
1107   while (isalnum (*p) || *p == '-' || *p == '_' ||
1108          /* Characters used by TUI specific commands.  */
1109          *p == '+' || *p == '<' || *p == '>' || *p == '$' ||
1110          /* Characters used for XDB compatibility.  */
1111          (xdb_commands && (*p == '!' || *p == '/' || *p == '?')))
1112     p++;
1113
1114   return p - text;
1115 }
1116
1117 /* This routine takes a line of TEXT and a CLIST in which to start the
1118    lookup.  When it returns it will have incremented the text pointer past
1119    the section of text it matched, set *RESULT_LIST to point to the list in
1120    which the last word was matched, and will return a pointer to the cmd
1121    list element which the text matches.  It will return NULL if no match at
1122    all was possible.  It will return -1 (cast appropriately, ick) if ambigous
1123    matches are possible; in this case *RESULT_LIST will be set to point to
1124    the list in which there are ambiguous choices (and *TEXT will be set to
1125    the ambiguous text string).
1126
1127    If the located command was an abbreviation, this routine returns the base
1128    command of the abbreviation.
1129
1130    It does no error reporting whatsoever; control will always return
1131    to the superior routine.
1132
1133    In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
1134    at the prefix_command (ie. the best match) *or* (special case) will be NULL
1135    if no prefix command was ever found.  For example, in the case of "info a",
1136    "info" matches without ambiguity, but "a" could be "args" or "address", so
1137    *RESULT_LIST is set to the cmd_list_element for "info".  So in this case
1138    RESULT_LIST should not be interpeted as a pointer to the beginning of a
1139    list; it simply points to a specific command.  In the case of an ambiguous
1140    return *TEXT is advanced past the last non-ambiguous prefix (e.g.
1141    "info t" can be "info types" or "info target"; upon return *TEXT has been
1142    advanced past "info ").
1143
1144    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
1145    affect the operation).
1146
1147    This routine does *not* modify the text pointed to by TEXT.
1148
1149    If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
1150    are actually help classes rather than commands (i.e. the function field of
1151    the struct cmd_list_element is NULL).  */
1152
1153 struct cmd_list_element *
1154 lookup_cmd_1 (char **text, struct cmd_list_element *clist,
1155               struct cmd_list_element **result_list, int ignore_help_classes)
1156 {
1157   char *command;
1158   int len, tmp, nfound;
1159   struct cmd_list_element *found, *c;
1160   char *line = *text;
1161
1162   while (**text == ' ' || **text == '\t')
1163     (*text)++;
1164
1165   /* Identify the name of the command.  */
1166   len = find_command_name_length (*text);
1167
1168   /* If nothing but whitespace, return 0.  */
1169   if (len == 0)
1170     return 0;
1171
1172   /* *text and p now bracket the first command word to lookup (and
1173      it's length is len).  We copy this into a local temporary */
1174
1175
1176   command = (char *) alloca (len + 1);
1177   memcpy (command, *text, len);
1178   command[len] = '\0';
1179
1180   /* Look it up.  */
1181   found = 0;
1182   nfound = 0;
1183   found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1184
1185   /* 
1186      ** We didn't find the command in the entered case, so lower case it
1187      ** and search again.
1188    */
1189   if (!found || nfound == 0)
1190     {
1191       for (tmp = 0; tmp < len; tmp++)
1192         {
1193           char x = command[tmp];
1194           command[tmp] = isupper (x) ? tolower (x) : x;
1195         }
1196       found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
1197     }
1198
1199   /* If nothing matches, we have a simple failure.  */
1200   if (nfound == 0)
1201     return 0;
1202
1203   if (nfound > 1)
1204     {
1205       if (result_list != NULL)
1206         /* Will be modified in calling routine
1207            if we know what the prefix command is.  */
1208         *result_list = 0;
1209       return (struct cmd_list_element *) -1;    /* Ambiguous.  */
1210     }
1211
1212   /* We've matched something on this list.  Move text pointer forward. */
1213
1214   *text += len;
1215
1216   if (found->cmd_pointer)
1217     {
1218       /* We drop the alias (abbreviation) in favor of the command it is
1219        pointing to.  If the alias is deprecated, though, we need to
1220        warn the user about it before we drop it.  Note that while we
1221        are warning about the alias, we may also warn about the command
1222        itself and we will adjust the appropriate DEPRECATED_WARN_USER
1223        flags */
1224       
1225       if (found->flags & DEPRECATED_WARN_USER)
1226         deprecated_cmd_warning (&line);
1227       found = found->cmd_pointer;
1228     }
1229   /* If we found a prefix command, keep looking.  */
1230
1231   if (found->prefixlist)
1232     {
1233       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
1234                         ignore_help_classes);
1235       if (!c)
1236         {
1237           /* Didn't find anything; this is as far as we got.  */
1238           if (result_list != NULL)
1239             *result_list = clist;
1240           return found;
1241         }
1242       else if (c == (struct cmd_list_element *) -1)
1243         {
1244           /* We've gotten this far properly, but the next step
1245              is ambiguous.  We need to set the result list to the best
1246              we've found (if an inferior hasn't already set it).  */
1247           if (result_list != NULL)
1248             if (!*result_list)
1249               /* This used to say *result_list = *found->prefixlist
1250                  If that was correct, need to modify the documentation
1251                  at the top of this function to clarify what is supposed
1252                  to be going on.  */
1253               *result_list = found;
1254           return c;
1255         }
1256       else
1257         {
1258           /* We matched!  */
1259           return c;
1260         }
1261     }
1262   else
1263     {
1264       if (result_list != NULL)
1265         *result_list = clist;
1266       return found;
1267     }
1268 }
1269
1270 /* All this hair to move the space to the front of cmdtype */
1271
1272 static void
1273 undef_cmd_error (char *cmdtype, char *q)
1274 {
1275   error (_("Undefined %scommand: \"%s\".  Try \"help%s%.*s\"."),
1276          cmdtype,
1277          q,
1278          *cmdtype ? " " : "",
1279          (int) strlen (cmdtype) - 1,
1280          cmdtype);
1281 }
1282
1283 /* Look up the contents of *LINE as a command in the command list LIST.
1284    LIST is a chain of struct cmd_list_element's.
1285    If it is found, return the struct cmd_list_element for that command
1286    and update *LINE to point after the command name, at the first argument.
1287    If not found, call error if ALLOW_UNKNOWN is zero
1288    otherwise (or if error returns) return zero.
1289    Call error if specified command is ambiguous,
1290    unless ALLOW_UNKNOWN is negative.
1291    CMDTYPE precedes the word "command" in the error message.
1292
1293    If INGNORE_HELP_CLASSES is nonzero, ignore any command list
1294    elements which are actually help classes rather than commands (i.e.
1295    the function field of the struct cmd_list_element is 0).  */
1296
1297 struct cmd_list_element *
1298 lookup_cmd (char **line, struct cmd_list_element *list, char *cmdtype,
1299             int allow_unknown, int ignore_help_classes)
1300 {
1301   struct cmd_list_element *last_list = 0;
1302   struct cmd_list_element *c;
1303
1304   /* Note: Do not remove trailing whitespace here because this
1305      would be wrong for complete_command.  Jim Kingdon  */
1306
1307   if (!*line)
1308     error (_("Lack of needed %scommand"), cmdtype);
1309
1310   c = lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
1311
1312   if (!c)
1313     {
1314       if (!allow_unknown)
1315         {
1316           char *q;
1317           int len = find_command_name_length (*line);
1318
1319           q = (char *) alloca (len + 1);
1320           strncpy (q, *line, len);
1321           q[len] = '\0';
1322           undef_cmd_error (cmdtype, q);
1323         }
1324       else
1325         return 0;
1326     }
1327   else if (c == (struct cmd_list_element *) -1)
1328     {
1329       /* Ambigous.  Local values should be off prefixlist or called
1330          values.  */
1331       int local_allow_unknown = (last_list ? last_list->allow_unknown :
1332                                  allow_unknown);
1333       char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
1334       struct cmd_list_element *local_list =
1335       (last_list ? *(last_list->prefixlist) : list);
1336
1337       if (local_allow_unknown < 0)
1338         {
1339           if (last_list)
1340             return last_list;   /* Found something.  */
1341           else
1342             return 0;           /* Found nothing.  */
1343         }
1344       else
1345         {
1346           /* Report as error.  */
1347           int amb_len;
1348           char ambbuf[100];
1349
1350           for (amb_len = 0;
1351                ((*line)[amb_len] && (*line)[amb_len] != ' '
1352                 && (*line)[amb_len] != '\t');
1353                amb_len++)
1354             ;
1355
1356           ambbuf[0] = 0;
1357           for (c = local_list; c; c = c->next)
1358             if (!strncmp (*line, c->name, amb_len))
1359               {
1360                 if (strlen (ambbuf) + strlen (c->name) + 6 < (int) sizeof ambbuf)
1361                   {
1362                     if (strlen (ambbuf))
1363                       strcat (ambbuf, ", ");
1364                     strcat (ambbuf, c->name);
1365                   }
1366                 else
1367                   {
1368                     strcat (ambbuf, "..");
1369                     break;
1370                   }
1371               }
1372           error (_("Ambiguous %scommand \"%s\": %s."), local_cmdtype,
1373                  *line, ambbuf);
1374           return 0;             /* lint */
1375         }
1376     }
1377   else
1378     {
1379       /* We've got something.  It may still not be what the caller
1380          wants (if this command *needs* a subcommand).  */
1381       while (**line == ' ' || **line == '\t')
1382         (*line)++;
1383
1384       if (c->prefixlist && **line && !c->allow_unknown)
1385         undef_cmd_error (c->prefixname, *line);
1386
1387       /* Seems to be what he wants.  Return it.  */
1388       return c;
1389     }
1390   return 0;
1391 }
1392
1393 /* We are here presumably because an alias or command in *TEXT is 
1394    deprecated and a warning message should be generated.  This function
1395    decodes *TEXT and potentially generates a warning message as outlined
1396    below.
1397    
1398    Example for 'set endian big' which has a fictitious alias 'seb'.
1399    
1400    If alias wasn't used in *TEXT, and the command is deprecated:
1401    "warning: 'set endian big' is deprecated." 
1402    
1403    If alias was used, and only the alias is deprecated:
1404    "warning: 'seb' an alias for the command 'set endian big' is deprecated."
1405    
1406    If alias was used and command is deprecated (regardless of whether the
1407    alias itself is deprecated:
1408    
1409    "warning: 'set endian big' (seb) is deprecated."
1410
1411    After the message has been sent, clear the appropriate flags in the
1412    command and/or the alias so the user is no longer bothered.
1413    
1414 */
1415 void
1416 deprecated_cmd_warning (char **text)
1417 {
1418   struct cmd_list_element *alias = NULL;
1419   struct cmd_list_element *prefix_cmd = NULL;
1420   struct cmd_list_element *cmd = NULL;
1421   struct cmd_list_element *c;
1422   char *type;
1423
1424   if (!lookup_cmd_composition (*text, &alias, &prefix_cmd, &cmd))
1425     /* return if text doesn't evaluate to a command */
1426     return;
1427
1428   if (!((alias ? (alias->flags & DEPRECATED_WARN_USER) : 0)
1429       || (cmd->flags & DEPRECATED_WARN_USER) ) ) 
1430     /* return if nothing is deprecated */
1431     return;
1432   
1433   printf_filtered ("Warning:");
1434   
1435   if (alias && !(cmd->flags & CMD_DEPRECATED))
1436     printf_filtered (" '%s', an alias for the", alias->name);
1437     
1438   printf_filtered (" command '");
1439   
1440   if (prefix_cmd)
1441     printf_filtered ("%s", prefix_cmd->prefixname);
1442   
1443   printf_filtered ("%s", cmd->name);
1444
1445   if (alias && (cmd->flags & CMD_DEPRECATED))
1446     printf_filtered ("' (%s) is deprecated.\n", alias->name);
1447   else
1448     printf_filtered ("' is deprecated.\n"); 
1449   
1450
1451   /* if it is only the alias that is deprecated, we want to indicate the
1452      new alias, otherwise we'll indicate the new command */
1453
1454   if (alias && !(cmd->flags & CMD_DEPRECATED))
1455     {
1456       if (alias->replacement)
1457       printf_filtered ("Use '%s'.\n\n", alias->replacement);
1458       else
1459       printf_filtered ("No alternative known.\n\n");
1460      }  
1461   else
1462     {
1463       if (cmd->replacement)
1464       printf_filtered ("Use '%s'.\n\n", cmd->replacement);
1465       else
1466       printf_filtered ("No alternative known.\n\n");
1467     }
1468
1469   /* We've warned you, now we'll keep quiet */
1470   if (alias)
1471     alias->flags &= ~DEPRECATED_WARN_USER;
1472   
1473   cmd->flags &= ~DEPRECATED_WARN_USER;
1474 }
1475
1476
1477
1478 /* Look up the contents of LINE as a command in the command list 'cmdlist'. 
1479    Return 1 on success, 0 on failure.
1480    
1481    If LINE refers to an alias, *alias will point to that alias.
1482    
1483    If LINE is a postfix command (i.e. one that is preceeded by a prefix
1484    command) set *prefix_cmd.
1485    
1486    Set *cmd to point to the command LINE indicates.
1487    
1488    If any of *alias, *prefix_cmd, or *cmd cannot be determined or do not 
1489    exist, they are NULL when we return.
1490    
1491 */
1492 int
1493 lookup_cmd_composition (char *text,
1494                       struct cmd_list_element **alias,
1495                       struct cmd_list_element **prefix_cmd, 
1496                       struct cmd_list_element **cmd)
1497 {
1498   char *command;
1499   int len, tmp, nfound;
1500   struct cmd_list_element *cur_list;
1501   struct cmd_list_element *prev_cmd;
1502   *alias = NULL;
1503   *prefix_cmd = NULL;
1504   *cmd = NULL;
1505   
1506   cur_list = cmdlist;
1507   
1508   while (1)
1509     { 
1510       /* Go through as many command lists as we need to 
1511        to find the command TEXT refers to. */
1512       
1513       prev_cmd = *cmd;
1514       
1515       while (*text == ' ' || *text == '\t')
1516       (text)++;
1517       
1518       /* Identify the name of the command.  */
1519       len = find_command_name_length (text);
1520       
1521       /* If nothing but whitespace, return.  */
1522       if (len == 0)
1523         return 0;
1524       
1525       /* text is the start of the first command word to lookup (and
1526        it's length is len).  We copy this into a local temporary */
1527       
1528       command = (char *) alloca (len + 1);
1529       memcpy (command, text, len);
1530       command[len] = '\0';
1531       
1532       /* Look it up.  */
1533       *cmd = 0;
1534       nfound = 0;
1535       *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1536       
1537       /* We didn't find the command in the entered case, so lower case it
1538        and search again.
1539       */
1540       if (!*cmd || nfound == 0)
1541       {
1542         for (tmp = 0; tmp < len; tmp++)
1543           {
1544             char x = command[tmp];
1545             command[tmp] = isupper (x) ? tolower (x) : x;
1546           }
1547         *cmd = find_cmd (command, len, cur_list, 1, &nfound);
1548       }
1549       
1550       if (*cmd == (struct cmd_list_element *) -1)
1551       {
1552         return 0;              /* ambiguous */
1553       }
1554       
1555       if (*cmd == NULL)
1556       return 0;                /* nothing found */
1557       else
1558       {
1559         if ((*cmd)->cmd_pointer)
1560           {
1561             /* cmd was actually an alias, we note that an alias was used 
1562                (by assigning *alais) and we set *cmd. 
1563              */
1564             *alias = *cmd;
1565             *cmd = (*cmd)->cmd_pointer;
1566           }
1567         *prefix_cmd = prev_cmd;
1568       }
1569       if ((*cmd)->prefixlist)
1570       cur_list = *(*cmd)->prefixlist;
1571       else
1572       return 1;
1573       
1574       text += len;
1575     }
1576 }
1577
1578 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1579
1580 /* Return a vector of char pointers which point to the different
1581    possible completions in LIST of TEXT.  
1582
1583    WORD points in the same buffer as TEXT, and completions should be
1584    returned relative to this position.  For example, suppose TEXT is "foo"
1585    and we want to complete to "foobar".  If WORD is "oo", return
1586    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1587
1588 char **
1589 complete_on_cmdlist (struct cmd_list_element *list, char *text, char *word)
1590 {
1591   struct cmd_list_element *ptr;
1592   char **matchlist;
1593   int sizeof_matchlist;
1594   int matches;
1595   int textlen = strlen (text);
1596
1597   sizeof_matchlist = 10;
1598   matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
1599   matches = 0;
1600
1601   for (ptr = list; ptr; ptr = ptr->next)
1602     if (!strncmp (ptr->name, text, textlen)
1603         && !ptr->abbrev_flag
1604         && (ptr->func
1605             || ptr->prefixlist))
1606       {
1607         if (matches == sizeof_matchlist)
1608           {
1609             sizeof_matchlist *= 2;
1610             matchlist = (char **) xrealloc ((char *) matchlist,
1611                                             (sizeof_matchlist
1612                                              * sizeof (char *)));
1613           }
1614
1615         matchlist[matches] = (char *)
1616           xmalloc (strlen (word) + strlen (ptr->name) + 1);
1617         if (word == text)
1618           strcpy (matchlist[matches], ptr->name);
1619         else if (word > text)
1620           {
1621             /* Return some portion of ptr->name.  */
1622             strcpy (matchlist[matches], ptr->name + (word - text));
1623           }
1624         else
1625           {
1626             /* Return some of text plus ptr->name.  */
1627             strncpy (matchlist[matches], word, text - word);
1628             matchlist[matches][text - word] = '\0';
1629             strcat (matchlist[matches], ptr->name);
1630           }
1631         ++matches;
1632       }
1633
1634   if (matches == 0)
1635     {
1636       xfree (matchlist);
1637       matchlist = 0;
1638     }
1639   else
1640     {
1641       matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1)
1642                                                         * sizeof (char *)));
1643       matchlist[matches] = (char *) 0;
1644     }
1645
1646   return matchlist;
1647 }
1648
1649 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
1650
1651 /* Return a vector of char pointers which point to the different
1652    possible completions in CMD of TEXT.  
1653
1654    WORD points in the same buffer as TEXT, and completions should be
1655    returned relative to this position.  For example, suppose TEXT is "foo"
1656    and we want to complete to "foobar".  If WORD is "oo", return
1657    "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
1658
1659 char **
1660 complete_on_enum (const char *enumlist[],
1661                   char *text,
1662                   char *word)
1663 {
1664   char **matchlist;
1665   int sizeof_matchlist;
1666   int matches;
1667   int textlen = strlen (text);
1668   int i;
1669   const char *name;
1670
1671   sizeof_matchlist = 10;
1672   matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
1673   matches = 0;
1674
1675   for (i = 0; (name = enumlist[i]) != NULL; i++)
1676     if (strncmp (name, text, textlen) == 0)
1677       {
1678         if (matches == sizeof_matchlist)
1679           {
1680             sizeof_matchlist *= 2;
1681             matchlist = (char **) xrealloc ((char *) matchlist,
1682                                             (sizeof_matchlist
1683                                              * sizeof (char *)));
1684           }
1685
1686         matchlist[matches] = (char *)
1687           xmalloc (strlen (word) + strlen (name) + 1);
1688         if (word == text)
1689           strcpy (matchlist[matches], name);
1690         else if (word > text)
1691           {
1692             /* Return some portion of name.  */
1693             strcpy (matchlist[matches], name + (word - text));
1694           }
1695         else
1696           {
1697             /* Return some of text plus name.  */
1698             strncpy (matchlist[matches], word, text - word);
1699             matchlist[matches][text - word] = '\0';
1700             strcat (matchlist[matches], name);
1701           }
1702         ++matches;
1703       }
1704
1705   if (matches == 0)
1706     {
1707       xfree (matchlist);
1708       matchlist = 0;
1709     }
1710   else
1711     {
1712       matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1)
1713                                                         * sizeof (char *)));
1714       matchlist[matches] = (char *) 0;
1715     }
1716
1717   return matchlist;
1718 }
1719
1720
1721 /* check function pointer */
1722 int
1723 cmd_func_p (struct cmd_list_element *cmd)
1724 {
1725   return (cmd->func != NULL);
1726 }
1727
1728
1729 /* call the command function */
1730 void
1731 cmd_func (struct cmd_list_element *cmd, char *args, int from_tty)
1732 {
1733   if (cmd_func_p (cmd))
1734     (*cmd->func) (cmd, args, from_tty);
1735   else
1736     error (_("Invalid command"));
1737 }