X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fcommand.c;h=fd8b8145288853df211ae0093e7961a46187ec0a;hb=feb129926a8d12656f1ca4b7a8bb10268d3af4fb;hp=0d2cfe7382ceab7e5dc01c275c938c78eb647903;hpb=0efe20a64246d8aca5e0f987063ba15181cd6290;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/command.c b/gdb/command.c
index 0d2cfe7382..fd8b814528 100644
--- a/gdb/command.c
+++ b/gdb/command.c
@@ -1,54 +1,68 @@
 /* Handle lists of commands, their decoding and documentation, for GDB.
-   Copyright 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
+   Copyright 1986, 1989, 1990, 1991, 1998 Free Software Foundation, Inc.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
 #include "gdbcmd.h"
 #include "symtab.h"
 #include "value.h"
 #include <ctype.h>
-#include <string.h>
+#include "gdb_string.h"
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_WAIT_H
+#include <wait.h>
+#else
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#endif
+
+#include "wait.h"
 
 /* Prototypes for local functions */
 
-static void
-undef_cmd_error PARAMS ((char *, char *));
+static void undef_cmd_error PARAMS ((char *, char *));
 
-static void
-show_user PARAMS ((char *, int));
+static void show_user PARAMS ((char *, int));
 
-static void
-show_user_1 PARAMS ((struct cmd_list_element *, FILE *));
+static void show_user_1 PARAMS ((struct cmd_list_element *, GDB_FILE *));
 
-static void
-make_command PARAMS ((char *, int));
+static void make_command PARAMS ((char *, int));
 
-static void
-shell_escape PARAMS ((char *, int));
+static void shell_escape PARAMS ((char *, int));
 
-static int
-parse_binary_operation PARAMS ((char *));
+static int parse_binary_operation PARAMS ((char *));
 
-static void
-print_doc_line PARAMS ((FILE *, char *));
+static void print_doc_line PARAMS ((GDB_FILE *, char *));
 
-extern void
-not_just_help_class_command PARAMS ((char *, int));
+static struct cmd_list_element *find_cmd PARAMS ((char *command,
+						  int len,
+					    struct cmd_list_element * clist,
+						  int ignore_help_classes,
+						  int *nfound));
 
-/* Add element named NAME to command list *LIST.
+void _initialize_command PARAMS ((void));
+
+/* Add element named NAME.
+   CLASS is the top level category into which commands are broken down
+   for "help" purposes.
    FUN should be the function to execute the command;
    it will get a character string as argument, with leading
    and trailing blanks already eliminated.
@@ -56,7 +70,12 @@ not_just_help_class_command PARAMS ((char *, int));
    DOC is a documentation string for the command.
    Its first line should be a complete sentence.
    It should start with ? for a command that is an abbreviation
-   or with * for a command that most users don't need to know about.  */
+   or with * for a command that most users don't need to know about.
+
+   Add this command to command list *LIST.  
+
+   Returns a pointer to the added command (not necessarily the head 
+   of *LIST). */
 
 struct cmd_list_element *
 add_cmd (name, class, fun, doc, list)
@@ -67,31 +86,51 @@ add_cmd (name, class, fun, doc, list)
      struct cmd_list_element **list;
 {
   register struct cmd_list_element *c
-    = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+  = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+  struct cmd_list_element *p;
 
   delete_cmd (name, list);
-  c->next = *list;
+
+  if (*list == NULL || STRCMP ((*list)->name, name) >= 0)
+    {
+      c->next = *list;
+      *list = c;
+    }
+  else
+    {
+      p = *list;
+      while (p->next && STRCMP (p->next->name, name) <= 0)
+	{
+	  p = p->next;
+	}
+      c->next = p->next;
+      p->next = c;
+    }
+
   c->name = name;
   c->class = class;
   c->function.cfunc = fun;
   c->doc = doc;
-  c->prefixlist = 0;
-  c->prefixname = (char *)NULL;
+  c->hook = NULL;
+  c->prefixlist = NULL;
+  c->prefixname = NULL;
   c->allow_unknown = 0;
   c->abbrev_flag = 0;
-  c->aux = 0;
-  c->type = not_set_cmd;
   c->completer = make_symbol_completion_list;
-  c->var = 0;
+  c->type = not_set_cmd;
+  c->var = NULL;
   c->var_type = var_boolean;
-  c->user_commands = 0;
-  *list = c;
+  c->enums = NULL;
+  c->user_commands = NULL;
+  c->hookee = NULL;
+  c->cmd_pointer = NULL;
+
   return c;
 }
 
 /* Same as above, except that the abbrev_flag is set. */
 
-#if 0	/* Currently unused */
+#if 0				/* Currently unused */
 
 struct cmd_list_element *
 add_abbrev_cmd (name, class, fun, doc, list)
@@ -102,7 +141,7 @@ add_abbrev_cmd (name, class, fun, doc, list)
      struct cmd_list_element **list;
 {
   register struct cmd_list_element *c
-    = add_cmd (name, class, fun, doc, list);
+  = add_cmd (name, class, fun, doc, list);
 
   c->abbrev_flag = 1;
   return c;
@@ -124,7 +163,7 @@ add_alias_cmd (name, oldname, class, abbrev_flag, list)
   register struct cmd_list_element *c;
   copied_name = (char *) alloca (strlen (oldname) + 1);
   strcpy (copied_name, oldname);
-  old  = lookup_cmd (&copied_name, *list, "", 1, 1);
+  old = lookup_cmd (&copied_name, *list, "", 1, 1);
 
   if (old == 0)
     {
@@ -137,7 +176,7 @@ add_alias_cmd (name, oldname, class, abbrev_flag, list)
   c->prefixname = old->prefixname;
   c->allow_unknown = old->allow_unknown;
   c->abbrev_flag = abbrev_flag;
-  c->aux = old->aux;
+  c->cmd_pointer = old;
   return c;
 }
 
@@ -166,7 +205,7 @@ add_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
 }
 
 /* Like add_prefix_cmd but sets the abbrev_flag on the new command. */
-   
+
 struct cmd_list_element *
 add_abbrev_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
 		       allow_unknown, list)
@@ -187,7 +226,7 @@ add_abbrev_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
   return c;
 }
 
-/* ARGSUSED */
+/* This is an empty "cfunc".  */
 void
 not_just_help_class_command (args, from_tty)
      char *args;
@@ -195,6 +234,17 @@ not_just_help_class_command (args, from_tty)
 {
 }
 
+/* This is an empty "sfunc".  */
+static void empty_sfunc PARAMS ((char *, int, struct cmd_list_element *));
+
+static void
+empty_sfunc (args, from_tty, c)
+     char *args;
+     int from_tty;
+     struct cmd_list_element *c;
+{
+}
+
 /* Add element named NAME to command list LIST (the list for set
    or some sublist thereof).
    CLASS is as in add_cmd.
@@ -211,43 +261,81 @@ add_set_cmd (name, class, var_type, var, doc, list)
      char *doc;
      struct cmd_list_element **list;
 {
-  /* For set/show, we have to call do_setshow_command
-     differently than an ordinary function (take commandlist as
-     well as arg), so the function field isn't helpful.  However,
-     function == NULL means that it's a help class, so set the function
-     to not_just_help_class_command.  */
   struct cmd_list_element *c
-    = add_cmd (name, class, not_just_help_class_command, doc, list);
+  = add_cmd (name, class, NO_FUNCTION, doc, list);
 
   c->type = set_cmd;
   c->var_type = var_type;
   c->var = var;
+  /* This needs to be something besides NO_FUNCTION so that this isn't
+     treated as a help class.  */
+  c->function.sfunc = empty_sfunc;
+  return c;
+}
+
+/* Add element named NAME to command list LIST (the list for set
+   or some sublist thereof).
+   CLASS is as in add_cmd.
+   ENUMLIST is a list of strings which may follow NAME.
+   VAR is address of the variable which will contain the matching string
+   (from ENUMLIST).
+   DOC is the documentation string.  */
+
+struct cmd_list_element *
+add_set_enum_cmd (name, class, enumlist, var, doc, list)
+     char *name;
+     enum command_class class;
+     char *enumlist[];
+     char *var;
+     char *doc;
+     struct cmd_list_element **list;
+{
+  struct cmd_list_element *c
+  = add_set_cmd (name, class, var_enum, var, doc, list);
+  c->enums = enumlist;
+
   return c;
 }
 
 /* Where SETCMD has already been added, add the corresponding show
-   command to LIST and return a pointer to it.  */
+   command to LIST and return a pointer to the added command (not 
+   necessarily the head of LIST).  */
 struct cmd_list_element *
 add_show_from_set (setcmd, list)
      struct cmd_list_element *setcmd;
      struct cmd_list_element **list;
 {
   struct cmd_list_element *showcmd =
-    (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+  (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+  struct cmd_list_element *p;
 
-  bcopy (setcmd, showcmd, sizeof (struct cmd_list_element));
+  memcpy (showcmd, setcmd, sizeof (struct cmd_list_element));
   delete_cmd (showcmd->name, list);
   showcmd->type = show_cmd;
-  
+
   /* Replace "set " at start of docstring with "show ".  */
   if (setcmd->doc[0] == 'S' && setcmd->doc[1] == 'e'
       && setcmd->doc[2] == 't' && setcmd->doc[3] == ' ')
     showcmd->doc = concat ("Show ", setcmd->doc + 4, NULL);
   else
-    fprintf (stderr, "GDB internal error: Bad docstring for set command\n");
-  
-  showcmd->next = *list;
-  *list = showcmd;
+    fprintf_unfiltered (gdb_stderr, "GDB internal error: Bad docstring for set command\n");
+
+  if (*list == NULL || STRCMP ((*list)->name, showcmd->name) >= 0)
+    {
+      showcmd->next = *list;
+      *list = showcmd;
+    }
+  else
+    {
+      p = *list;
+      while (p->next && STRCMP (p->next->name, showcmd->name) <= 0)
+	{
+	  p = p->next;
+	}
+      showcmd->next = p->next;
+      p->next = showcmd;
+    }
+
   return showcmd;
 }
 
@@ -261,20 +349,24 @@ delete_cmd (name, list)
   register struct cmd_list_element *c;
   struct cmd_list_element *p;
 
-  while (*list && !strcmp ((*list)->name, name))
+  while (*list && STREQ ((*list)->name, name))
     {
+      if ((*list)->hookee)
+	(*list)->hookee->hook = 0;	/* Hook slips out of its mouth */
       p = (*list)->next;
-      free ((PTR)*list);
+      free ((PTR) * list);
       *list = p;
     }
 
   if (*list)
     for (c = *list; c->next;)
       {
-	if (!strcmp (c->next->name, name))
+	if (STREQ (c->next->name, name))
 	  {
+	    if (c->next->hookee)
+	      c->next->hookee->hook = 0;	/* hooked cmd gets away.  */
 	    p = c->next->next;
-	    free ((PTR)c->next);
+	    free ((PTR) c->next);
 	    c->next = p;
 	  }
 	else
@@ -296,7 +388,7 @@ delete_cmd (name, list)
 void
 help_cmd (command, stream)
      char *command;
-     FILE *stream;
+     GDB_FILE *stream;
 {
   struct cmd_list_element *c;
   extern struct cmd_list_element *cmdlist;
@@ -315,10 +407,10 @@ help_cmd (command, stream)
   /* There are three cases here.
      If c->prefixlist is nonzero, we have a prefix command.
      Print its documentation, then list its subcommands.
-     
+
      If c->function is nonzero, we really have a command.
      Print its documentation and return.
-     
+
      If c->function is zero, we have a class name.
      Print its documentation (as if it were a command)
      and then set class to the number of this class
@@ -338,6 +430,10 @@ help_cmd (command, stream)
   /* If this is a class name, print all of the commands in the class */
   if (c->function.cfunc == NULL)
     help_list (cmdlist, "", c->class, stream);
+
+  if (c->hook)
+    fprintf_filtered (stream, "\nThis command has a hook defined: %s\n",
+		      c->hook->name);
 }
 
 /*
@@ -357,11 +453,11 @@ help_list (list, cmdtype, class, stream)
      struct cmd_list_element *list;
      char *cmdtype;
      enum command_class class;
-     FILE *stream;
+     GDB_FILE *stream;
 {
   int len;
   char *cmdtype1, *cmdtype2;
-  
+
   /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub"  */
   len = strlen (cmdtype);
   cmdtype1 = (char *) alloca (len + 1);
@@ -382,23 +478,23 @@ help_list (list, cmdtype, class, stream)
   else
     fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
 
-  help_cmd_list (list, class, cmdtype, (int)class >= 0, stream);
+  help_cmd_list (list, class, cmdtype, (int) class >= 0, stream);
 
   if (class == all_classes)
     fprintf_filtered (stream, "\n\
 Type \"help%s\" followed by a class name for a list of commands in that class.",
-	     cmdtype1);
+		      cmdtype1);
 
   fprintf_filtered (stream, "\n\
 Type \"help%s\" followed by %scommand name for full documentation.\n\
 Command name abbreviations are allowed if unambiguous.\n",
-	   cmdtype1, cmdtype2);
+		    cmdtype1, cmdtype2);
 }
-     
+
 /* Print only the first line of STR on STREAM.  */
 static void
 print_doc_line (stream, str)
-     FILE *stream;
+     GDB_FILE *stream;
      char *str;
 {
   static char *line_buffer = 0;
@@ -417,7 +513,7 @@ print_doc_line (stream, str)
   if (p - str > line_size - 1)
     {
       line_size = p - str + 1;
-      free ((PTR)line_buffer);
+      free ((PTR) line_buffer);
       line_buffer = (char *) xmalloc (line_size);
     }
   strncpy (line_buffer, str, p - str);
@@ -434,10 +530,10 @@ print_doc_line (stream, str)
  * PREFIX is the prefix to print before each command name.
  * STREAM is the stream upon which the output should be written.
  * CLASS should be:
- *	A non-negative class number to list only commands in that
+ *      A non-negative class number to list only commands in that
  * class.
- *	ALL_COMMANDS to list all commands in list.
- *	ALL_CLASSES  to list all classes in list.
+ *      ALL_COMMANDS to list all commands in list.
+ *      ALL_CLASSES  to list all classes in list.
  *
  *   Note that RECURSE will be active on *all* sublists, not just the
  * ones selected by the criteria above (ie. the selection mechanism
@@ -449,7 +545,7 @@ help_cmd_list (list, class, prefix, recurse, stream)
      enum command_class class;
      char *prefix;
      int recurse;
-     FILE *stream;
+     GDB_FILE *stream;
 {
   register struct cmd_list_element *c;
 
@@ -457,8 +553,8 @@ help_cmd_list (list, class, prefix, recurse, stream)
     {
       if (c->abbrev_flag == 0 &&
 	  (class == all_commands
-	  || (class == all_classes && c->function.cfunc == NULL)
-	  || (class == c->class && c->function.cfunc != NULL)))
+	   || (class == all_classes && c->function.cfunc == NULL)
+	   || (class == c->class && c->function.cfunc != NULL)))
 	{
 	  fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
 	  print_doc_line (stream, c->doc);
@@ -471,36 +567,73 @@ help_cmd_list (list, class, prefix, recurse, stream)
     }
 }
 
-/* This routine takes a line of TEXT and a CLIST in which to
-   start the lookup.  When it returns it will have incremented the text
-   pointer past the section of text it matched, set *RESULT_LIST to
-   the list in which the last word was matched, and will return the
-   cmd list element which the text matches.  It will return 0 if no
-   match at all was possible.  It will return -1 if ambigous matches are
-   possible; in this case *RESULT_LIST will be set to the list in which
-   there are ambiguous choices (and text will be set to the ambiguous
-   text string).
+
+/* Search the input clist for 'command'.  Return the command if
+   found (or NULL if not), and return the number of commands
+   found in nfound */
+
+static struct cmd_list_element *
+find_cmd (command, len, clist, ignore_help_classes, nfound)
+     char *command;
+     int len;
+     struct cmd_list_element *clist;
+     int ignore_help_classes;
+     int *nfound;
+{
+  struct cmd_list_element *found, *c;
+
+  found = (struct cmd_list_element *) NULL;
+  *nfound = 0;
+  for (c = clist; c; c = c->next)
+    if (!strncmp (command, c->name, len)
+	&& (!ignore_help_classes || c->function.cfunc))
+      {
+	found = c;
+	(*nfound)++;
+	if (c->name[len] == '\0')
+	  {
+	    *nfound = 1;
+	    break;
+	  }
+      }
+  return found;
+}
+
+/* This routine takes a line of TEXT and a CLIST in which to start the
+   lookup.  When it returns it will have incremented the text pointer past
+   the section of text it matched, set *RESULT_LIST to point to the list in
+   which the last word was matched, and will return a pointer to the cmd
+   list element which the text matches.  It will return NULL if no match at
+   all was possible.  It will return -1 (cast appropriately, ick) if ambigous
+   matches are possible; in this case *RESULT_LIST will be set to point to
+   the list in which there are ambiguous choices (and *TEXT will be set to
+   the ambiguous text string).
+
+   If the located command was an abbreviation, this routine returns the base
+   command of the abbreviation.
 
    It does no error reporting whatsoever; control will always return
    to the superior routine.
 
-   In the case of an ambiguous return (-1), *RESULT_LIST will be set to
-   point at the prefix_command (ie. the best match) *or* (special
-   case) will be 0 if no prefix command was ever found.  For example,
-   in the case of "info a", "info" matches without ambiguity, but "a"
-   could be "args" or "address", so *RESULT_LIST is set to
-   the cmd_list_element for "info".  So in this case
-   result list should not be interpeted as a pointer to the beginning
-   of a list; it simply points to a specific command.
+   In the case of an ambiguous return (-1), *RESULT_LIST will be set to point
+   at the prefix_command (ie. the best match) *or* (special case) will be NULL
+   if no prefix command was ever found.  For example, in the case of "info a",
+   "info" matches without ambiguity, but "a" could be "args" or "address", so
+   *RESULT_LIST is set to the cmd_list_element for "info".  So in this case
+   RESULT_LIST should not be interpeted as a pointer to the beginning of a
+   list; it simply points to a specific command.  In the case of an ambiguous
+   return *TEXT is advanced past the last non-ambiguous prefix (e.g.
+   "info t" can be "info types" or "info target"; upon return *TEXT has been
+   advanced past "info ").
 
    If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise
    affect the operation).
 
    This routine does *not* modify the text pointed to by TEXT.
-   
-   If IGNORE_HELP_CLASSES is nonzero, ignore any command list
-   elements which are actually help classes rather than commands (i.e.
-   the function field of the struct cmd_list_element is 0).  */
+
+   If IGNORE_HELP_CLASSES is nonzero, ignore any command list elements which
+   are actually help classes rather than commands (i.e. the function field of
+   the struct cmd_list_element is NULL).  */
 
 struct cmd_list_element *
 lookup_cmd_1 (text, clist, result_list, ignore_help_classes)
@@ -519,43 +652,49 @@ lookup_cmd_1 (text, clist, result_list, ignore_help_classes)
      so that "set args_foo()" doesn't get interpreted as
      "set args _foo()".  */
   for (p = *text;
-       *p && (isalnum(*p) || *p == '-' || *p == '_');
+       *p && (isalnum (*p) || *p == '-' || *p == '_' ||
+	      (tui_version &&
+	       (*p == '+' || *p == '<' || *p == '>' || *p == '$')) ||
+	      (xdb_commands && (*p == '!' || *p == '/' || *p == '?')));
        p++)
     ;
 
   /* If nothing but whitespace, return 0.  */
   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,
-     converting to lower case as we go.  */
+     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] = isupper(x) ? tolower(x) : x;
+      command[tmp] = x;
     }
   command[len] = '\0';
 
   /* Look it up.  */
   found = 0;
   nfound = 0;
-  for (c = clist; c; c = c->next)
-    if (!strncmp (command, c->name, len)
-	&& (!ignore_help_classes || c->function.cfunc))
-      {
-	found = c;
-	nfound++;
-	if (c->name[len] == '\0')
-	  {
-	    nfound = 1;
-	    break;
-	  }
-      }
+  found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
+
+  /* 
+     ** We didn't find the command in the entered case, so lower case it
+     ** and search again.
+   */
+  if (!found || nfound == 0)
+    {
+      for (tmp = 0; tmp < len; tmp++)
+	{
+	  char x = command[tmp];
+	  command[tmp] = isupper (x) ? tolower (x) : x;
+	}
+      found = find_cmd (command, len, clist, ignore_help_classes, &nfound);
+    }
 
   /* If nothing matches, we have a simple failure.  */
   if (nfound == 0)
@@ -566,13 +705,21 @@ lookup_cmd_1 (text, clist, result_list, ignore_help_classes)
       if (result_list != NULL)
 	/* Will be modified in calling routine
 	   if we know what the prefix command is.  */
-	*result_list = 0;		
-      return (struct cmd_list_element *) -1; /* Ambiguous.  */
+	*result_list = 0;
+      return (struct cmd_list_element *) -1;	/* Ambiguous.  */
     }
 
   /* We've matched something on this list.  Move text pointer forward. */
 
   *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)
     {
       c = lookup_cmd_1 (text, *found->prefixlist, result_list,
@@ -586,15 +733,15 @@ lookup_cmd_1 (text, clist, result_list, ignore_help_classes)
 	}
       else if (c == (struct cmd_list_element *) -1)
 	{
-	  /* We've gotten this far properley, but the next step
+	  /* We've gotten this far properly, but the next step
 	     is ambiguous.  We need to set the result list to the best
 	     we've found (if an inferior hasn't already set it).  */
 	  if (result_list != NULL)
 	    if (!*result_list)
 	      /* This used to say *result_list = *found->prefixlist
-		 If that was correct, need to modify the documentation
-		 at the top of this function to clarify what is supposed
-		 to be going on.  */
+	         If that was correct, need to modify the documentation
+	         at the top of this function to clarify what is supposed
+	         to be going on.  */
 	      *result_list = found;
 	  return c;
 	}
@@ -619,11 +766,11 @@ undef_cmd_error (cmdtype, q)
      char *cmdtype, *q;
 {
   error ("Undefined %scommand: \"%s\".  Try \"help%s%.*s\".",
-    cmdtype,
-    q,
-    *cmdtype? " ": "",
-    strlen(cmdtype)-1,
-    cmdtype);
+	 cmdtype,
+	 q,
+	 *cmdtype ? " " : "",
+	 strlen (cmdtype) - 1,
+	 cmdtype);
 }
 
 /* Look up the contents of *LINE as a command in the command list LIST.
@@ -650,14 +797,17 @@ lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
 {
   struct cmd_list_element *last_list = 0;
   struct cmd_list_element *c =
-    lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
+  lookup_cmd_1 (line, list, &last_list, ignore_help_classes);
+#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--;
   *(ptr + 1) = '\0';
-  
+#endif
+
   if (!c)
     {
       if (!allow_unknown)
@@ -668,12 +818,12 @@ lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
 	    {
 	      char *p = *line, *q;
 
-	      while (isalnum(*p) || *p == '-')
+	      while (isalnum (*p) || *p == '-')
 		p++;
 
 	      q = (char *) alloca (p - *line + 1);
 	      strncpy (q, *line, p - *line);
-	      q[p-*line] = '\0';
+	      q[p - *line] = '\0';
 	      undef_cmd_error (cmdtype, q);
 	    }
 	}
@@ -683,13 +833,13 @@ lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
   else if (c == (struct cmd_list_element *) -1)
     {
       /* Ambigous.  Local values should be off prefixlist or called
-	 values.  */
+         values.  */
       int local_allow_unknown = (last_list ? last_list->allow_unknown :
 				 allow_unknown);
       char *local_cmdtype = last_list ? last_list->prefixname : cmdtype;
       struct cmd_list_element *local_list =
-	(last_list ? *(last_list->prefixlist) : list);
-      
+      (last_list ? *(last_list->prefixlist) : list);
+
       if (local_allow_unknown < 0)
 	{
 	  if (last_list)
@@ -708,12 +858,12 @@ lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
 		&& (*line)[amb_len] != '\t');
 	       amb_len++)
 	    ;
-	  
+
 	  ambbuf[0] = 0;
 	  for (c = local_list; c; c = c->next)
 	    if (!strncmp (*line, c->name, amb_len))
 	      {
-		if (strlen (ambbuf) + strlen (c->name) + 6 < (int)sizeof ambbuf)
+		if (strlen (ambbuf) + strlen (c->name) + 6 < (int) sizeof ambbuf)
 		  {
 		    if (strlen (ambbuf))
 		      strcat (ambbuf, ", ");
@@ -745,7 +895,7 @@ lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
     }
   return 0;
 }
-	
+
 #if 0
 /* Look up the contents of *LINE as a command in the command list LIST.
    LIST is a chain of struct cmd_list_element's.
@@ -786,7 +936,7 @@ lookup_cmd (line, list, cmdtype, allow_unknown)
   /* Find end of command name.  */
 
   p = *line;
-  while (*p == '-' || isalnum(*p))
+  while (*p == '-' || isalnum (*p))
     p++;
 
   /* Look up the command name.
@@ -801,18 +951,18 @@ lookup_cmd (line, list, cmdtype, allow_unknown)
 	error ("Lack of needed %scommand", cmdtype);
       return 0;
     }
-  
+
   /* Copy over to a local buffer, converting to lowercase on the way.
      This is in case the command being parsed is a subcommand which
      doesn't match anything, and that's ok.  We want the original
      untouched for the routine of the original command.  */
-  
+
   processed_cmd = (char *) alloca (p - *line + 1);
   for (cmd_len = 0; cmd_len < p - *line; cmd_len++)
     {
       char x = (*line)[cmd_len];
-      if (isupper(x))
-	processed_cmd[cmd_len] = tolower(x);
+      if (isupper (x))
+	processed_cmd[cmd_len] = tolower (x);
       else
 	processed_cmd[cmd_len] = x;
     }
@@ -867,7 +1017,8 @@ lookup_cmd (line, list, cmdtype, allow_unknown)
 
   /* Skip whitespace before the argument.  */
 
-  while (*p == ' ' || *p == '\t') p++;
+  while (*p == ' ' || *p == '\t')
+    p++;
   *line = p;
 
   if (found->prefixlist && *p)
@@ -885,12 +1036,18 @@ lookup_cmd (line, list, cmdtype, allow_unknown)
 /* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
 
 /* Return a vector of char pointers which point to the different
-   possible completions in LIST of TEXT.  */
+   possible completions in LIST of TEXT.  
+
+   WORD points in the same buffer as TEXT, and completions should be
+   returned relative to this position.  For example, suppose TEXT is "foo"
+   and we want to complete to "foobar".  If WORD is "oo", return
+   "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
 
 char **
-complete_on_cmdlist (list, text)
+complete_on_cmdlist (list, text, word)
      struct cmd_list_element *list;
      char *text;
+     char *word;
 {
   struct cmd_list_element *ptr;
   char **matchlist;
@@ -911,25 +1068,111 @@ complete_on_cmdlist (list, text)
 	if (matches == sizeof_matchlist)
 	  {
 	    sizeof_matchlist *= 2;
-	    matchlist = (char **) xrealloc ((char *)matchlist,
+	    matchlist = (char **) xrealloc ((char *) matchlist,
+					    (sizeof_matchlist
+					     * sizeof (char *)));
+	  }
+
+	matchlist[matches] = (char *)
+	  xmalloc (strlen (word) + strlen (ptr->name) + 1);
+	if (word == text)
+	  strcpy (matchlist[matches], ptr->name);
+	else if (word > text)
+	  {
+	    /* Return some portion of ptr->name.  */
+	    strcpy (matchlist[matches], ptr->name + (word - text));
+	  }
+	else
+	  {
+	    /* Return some of text plus ptr->name.  */
+	    strncpy (matchlist[matches], word, text - word);
+	    matchlist[matches][text - word] = '\0';
+	    strcat (matchlist[matches], ptr->name);
+	  }
+	++matches;
+      }
+
+  if (matches == 0)
+    {
+      free ((PTR) matchlist);
+      matchlist = 0;
+    }
+  else
+    {
+      matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1)
+							* sizeof (char *)));
+      matchlist[matches] = (char *) 0;
+    }
+
+  return matchlist;
+}
+
+/* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
+
+/* Return a vector of char pointers which point to the different
+   possible completions in CMD of TEXT.  
+
+   WORD points in the same buffer as TEXT, and completions should be
+   returned relative to this position.  For example, suppose TEXT is "foo"
+   and we want to complete to "foobar".  If WORD is "oo", return
+   "oobar"; if WORD is "baz/foo", return "baz/foobar".  */
+
+char **
+complete_on_enum (enumlist, text, word)
+     char **enumlist;
+     char *text;
+     char *word;
+{
+  char **matchlist;
+  int sizeof_matchlist;
+  int matches;
+  int textlen = strlen (text);
+  int i;
+  char *name;
+
+  sizeof_matchlist = 10;
+  matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
+  matches = 0;
+
+  for (i = 0; (name = enumlist[i]) != NULL; i++)
+    if (strncmp (name, text, textlen) == 0)
+      {
+	if (matches == sizeof_matchlist)
+	  {
+	    sizeof_matchlist *= 2;
+	    matchlist = (char **) xrealloc ((char *) matchlist,
 					    (sizeof_matchlist
 					     * sizeof (char *)));
 	  }
 
-	matchlist[matches] = (char *) 
-	  xmalloc (strlen (ptr->name) + 1);
-	strcpy (matchlist[matches++], ptr->name);
+	matchlist[matches] = (char *)
+	  xmalloc (strlen (word) + strlen (name) + 1);
+	if (word == text)
+	  strcpy (matchlist[matches], name);
+	else if (word > text)
+	  {
+	    /* Return some portion of name.  */
+	    strcpy (matchlist[matches], name + (word - text));
+	  }
+	else
+	  {
+	    /* Return some of text plus name.  */
+	    strncpy (matchlist[matches], word, text - word);
+	    matchlist[matches][text - word] = '\0';
+	    strcat (matchlist[matches], name);
+	  }
+	++matches;
       }
 
   if (matches == 0)
     {
-      free ((PTR)matchlist);
+      free ((PTR) matchlist);
       matchlist = 0;
     }
   else
     {
-      matchlist = (char **) xrealloc ((char *)matchlist, ((matches + 1)
-						* sizeof (char *)));
+      matchlist = (char **) xrealloc ((char *) matchlist, ((matches + 1)
+							* sizeof (char *)));
       matchlist[matches] = (char *) 0;
     }
 
@@ -954,16 +1197,15 @@ parse_binary_operation (arg)
       || !strncmp (arg, "1", length)
       || !strncmp (arg, "yes", length))
     return 1;
+  else if (!strncmp (arg, "off", length)
+	   || !strncmp (arg, "0", length)
+	   || !strncmp (arg, "no", length))
+    return 0;
   else
-    if (!strncmp (arg, "off", length)
-	|| !strncmp (arg, "0", length)
-	|| !strncmp (arg, "no", length))
+    {
+      error ("\"on\" or \"off\" expected.");
       return 0;
-    else 
-      {
-	error ("\"on\" or \"off\" expected.");
-	return 0;
-      }
+    }
 }
 
 /* Do a "set" or "show" command.  ARG is NULL if no argument, or the text
@@ -986,50 +1228,58 @@ do_setshow_command (arg, from_tty, c)
 	    char *p;
 	    char *q;
 	    int ch;
-	    
+
 	    if (arg == NULL)
 	      arg = "";
 	    new = (char *) xmalloc (strlen (arg) + 2);
-	    p = arg; q = new;
+	    p = arg;
+	    q = new;
 	    while ((ch = *p++) != '\000')
 	      {
 		if (ch == '\\')
 		  {
 		    /* \ at end of argument is used after spaces
 		       so they won't be lost.  */
+		    /* This is obsolete now that we no longer strip
+		       trailing whitespace and actually, the backslash
+		       didn't get here in my test, readline or
+		       something did something funky with a backslash
+		       right before a newline.  */
 		    if (*p == 0)
 		      break;
 		    ch = parse_escape (&p);
 		    if (ch == 0)
-		      break; /* C loses */
+		      break;	/* C loses */
 		    else if (ch > 0)
 		      *q++ = ch;
 		  }
 		else
 		  *q++ = ch;
 	      }
+#if 0
 	    if (*(p - 1) != '\\')
 	      *q++ = ' ';
+#endif
 	    *q++ = '\0';
 	    new = (char *) xrealloc (new, q - new);
-	    if (*(char **)c->var != NULL)
-	      free (*(char **)c->var);
+	    if (*(char **) c->var != NULL)
+	      free (*(char **) c->var);
 	    *(char **) c->var = new;
 	  }
 	  break;
 	case var_string_noescape:
 	  if (arg == NULL)
 	    arg = "";
-	  if (*(char **)c->var != NULL)
-	    free (*(char **)c->var);
+	  if (*(char **) c->var != NULL)
+	    free (*(char **) c->var);
 	  *(char **) c->var = savestring (arg, strlen (arg));
 	  break;
 	case var_filename:
 	  if (arg == NULL)
 	    error_no_arg ("filename to set it to.");
-	  if (*(char **)c->var != NULL)
-	    free (*(char **)c->var);
-	  *(char **)c->var = tilde_expand (arg);
+	  if (*(char **) c->var != NULL)
+	    free (*(char **) c->var);
+	  *(char **) c->var = tilde_expand (arg);
 	  break;
 	case var_boolean:
 	  *(int *) c->var = parse_binary_operation (arg);
@@ -1037,15 +1287,76 @@ do_setshow_command (arg, from_tty, c)
 	case var_uinteger:
 	  if (arg == NULL)
 	    error_no_arg ("integer to set it to.");
-	  *(int *) c->var = parse_and_eval_address (arg);
-	  if (*(int *) c->var == 0)
-	    *(int *) c->var = UINT_MAX;
+	  *(unsigned int *) c->var = parse_and_eval_address (arg);
+	  if (*(unsigned int *) c->var == 0)
+	    *(unsigned int *) c->var = UINT_MAX;
 	  break;
+	case var_integer:
+	  {
+	    unsigned int val;
+	    if (arg == NULL)
+	      error_no_arg ("integer to set it to.");
+	    val = parse_and_eval_address (arg);
+	    if (val == 0)
+	      *(int *) c->var = INT_MAX;
+	    else if (val >= INT_MAX)
+	      error ("integer %u out of range", val);
+	    else
+	      *(int *) c->var = val;
+	    break;
+	  }
 	case var_zinteger:
 	  if (arg == NULL)
 	    error_no_arg ("integer to set it to.");
 	  *(int *) c->var = parse_and_eval_address (arg);
 	  break;
+	case var_enum:
+	  {
+	    int i;
+	    int len;
+	    int nmatches;
+	    char *match = NULL;
+	    char *p;
+
+	    /* if no argument was supplied, print an informative error message */
+	    if (arg == NULL)
+	      {
+		char msg[1024];
+		strcpy (msg, "Requires an argument. Valid arguments are ");
+		for (i = 0; c->enums[i]; i++)
+		  {
+		    if (i != 0)
+		      strcat (msg, ", ");
+		    strcat (msg, c->enums[i]);
+		  }
+		strcat (msg, ".");
+		error (msg);
+	      }
+
+	    p = strchr (arg, ' ');
+
+	    if (p)
+	      len = p - arg;
+	    else
+	      len = strlen (arg);
+
+	    nmatches = 0;
+	    for (i = 0; c->enums[i]; i++)
+	      if (strncmp (arg, c->enums[i], len) == 0)
+		{
+		  match = c->enums[i];
+		  nmatches++;
+		}
+
+	    if (nmatches <= 0)
+	      error ("Undefined item: \"%s\".", arg);
+
+	    if (nmatches > 1)
+	      error ("Ambiguous item \"%s\".", arg);
+
+	    *(char **) c->var = match;
+	  }
+	  break;
 	default:
 	  error ("gdb internal error: bad var_type in do_setshow_command");
 	}
@@ -1053,43 +1364,56 @@ do_setshow_command (arg, from_tty, c)
   else if (c->type == show_cmd)
     {
       /* Print doc minus "show" at start.  */
-      print_doc_line (stdout, c->doc + 5);
-      
-      fputs_filtered (" is ", stdout);
+      print_doc_line (gdb_stdout, c->doc + 5);
+
+      fputs_filtered (" is ", gdb_stdout);
       wrap_here ("    ");
       switch (c->var_type)
 	{
-      case var_string:
-	{
-	  unsigned char *p;
-	  fputs_filtered ("\"", stdout);
-	  for (p = *(unsigned char **) c->var; *p != '\0'; p++)
-	    printchar (*p, stdout, '"');
-	  fputs_filtered ("\"", stdout);
-	}
-	break;
-      case var_string_noescape:
-      case var_filename:
-	fputs_filtered ("\"", stdout);
-	fputs_filtered (*(char **) c->var, stdout);
-	fputs_filtered ("\"", stdout);
-	break;
-      case var_boolean:
-	fputs_filtered (*(int *) c->var ? "on" : "off", stdout);
-	break;
-      case var_uinteger:
-	if (*(unsigned int *) c->var == UINT_MAX) {
-	  fputs_filtered ("unlimited", stdout);
+	case var_string:
+	  {
+	    unsigned char *p;
+
+	    fputs_filtered ("\"", gdb_stdout);
+	    if (*(unsigned char **) c->var)
+	      fputstr_filtered (*(unsigned char **) c->var, '"', gdb_stdout);
+	    fputs_filtered ("\"", gdb_stdout);
+	  }
+	  break;
+	case var_string_noescape:
+	case var_filename:
+	case var_enum:
+	  fputs_filtered ("\"", gdb_stdout);
+	  if (*(char **) c->var)
+	    fputs_filtered (*(char **) c->var, gdb_stdout);
+	  fputs_filtered ("\"", gdb_stdout);
+	  break;
+	case var_boolean:
+	  fputs_filtered (*(int *) c->var ? "on" : "off", gdb_stdout);
+	  break;
+	case var_uinteger:
+	  if (*(unsigned int *) c->var == UINT_MAX)
+	    {
+	      fputs_filtered ("unlimited", gdb_stdout);
+	      break;
+	    }
+	  /* else fall through */
+	case var_zinteger:
+	  fprintf_filtered (gdb_stdout, "%u", *(unsigned int *) c->var);
+	  break;
+	case var_integer:
+	  if (*(int *) c->var == INT_MAX)
+	    {
+	      fputs_filtered ("unlimited", gdb_stdout);
+	    }
+	  else
+	    fprintf_filtered (gdb_stdout, "%d", *(int *) c->var);
 	  break;
+
+	default:
+	  error ("gdb internal error: bad var_type in do_setshow_command");
 	}
-	/* else fall through */
-      case var_zinteger:
-	fprintf_filtered (stdout, "%d", *(unsigned int *) c->var);
-	break;
-      default:
-	error ("gdb internal error: bad var_type in do_setshow_command");
-      }
-      fputs_filtered (".\n", stdout);
+      fputs_filtered (".\n", gdb_stdout);
     }
   else
     error ("gdb internal error: bad cmd_type in do_setshow_command");
@@ -1104,19 +1428,20 @@ cmd_show_list (list, from_tty, prefix)
      int from_tty;
      char *prefix;
 {
-  for (; list != NULL; list = list->next) {
-    /* If we find a prefix, run its list, prefixing our output by its
-       prefix (with "show " skipped).  */
-    if (list->prefixlist && !list->abbrev_flag)
-      cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5);
-    if (list->type == show_cmd)
-      {
-	fputs_filtered (prefix, stdout);
-	fputs_filtered (list->name, stdout);
-	fputs_filtered (":  ", stdout);
-	do_setshow_command ((char *)NULL, from_tty, list);
-      }
-  }
+  for (; list != NULL; list = list->next)
+    {
+      /* If we find a prefix, run its list, prefixing our output by its
+         prefix (with "show " skipped).  */
+      if (list->prefixlist && !list->abbrev_flag)
+	cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5);
+      if (list->type == show_cmd)
+	{
+	  fputs_filtered (prefix, gdb_stdout);
+	  fputs_filtered (list->name, gdb_stdout);
+	  fputs_filtered (":  ", gdb_stdout);
+	  do_setshow_command ((char *) NULL, from_tty, list);
+	}
+    }
 }
 
 /* ARGSUSED */
@@ -1125,6 +1450,11 @@ shell_escape (arg, from_tty)
      char *arg;
      int from_tty;
 {
+#ifdef CANT_FORK
+  /* FIXME: what about errors (I don't know how GO32 system() handles
+     them)?  */
+  system (arg);
+#else /* Can fork.  */
   int rc, status, pid;
   char *p, *user_shell;
 
@@ -1137,15 +1467,17 @@ shell_escape (arg, from_tty)
   else
     p++;			/* Get past '/' */
 
-  if ((pid = fork()) == 0)
+  if ((pid = fork ()) == 0)
     {
       if (!arg)
 	execl (user_shell, p, 0);
       else
 	execl (user_shell, p, "-c", arg, 0);
 
-      fprintf (stderr, "Exec of shell failed\n");
-      exit (0);
+      fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
+			  safe_strerror (errno));
+      gdb_flush (gdb_stderr);
+      _exit (0177);
     }
 
   if (pid != -1)
@@ -1153,6 +1485,7 @@ shell_escape (arg, from_tty)
       ;
   else
     error ("Fork failed");
+#endif /* Can fork.  */
 }
 
 static void
@@ -1166,28 +1499,31 @@ make_command (arg, from_tty)
     p = "make";
   else
     {
-      p = xmalloc (sizeof("make ") + strlen(arg));
+      p = xmalloc (sizeof ("make ") + strlen (arg));
       strcpy (p, "make ");
-      strcpy (p + sizeof("make ")-1, arg);
+      strcpy (p + sizeof ("make ") - 1, arg);
     }
-  
+
   shell_escape (p, from_tty);
 }
 
 static void
 show_user_1 (c, stream)
      struct cmd_list_element *c;
-     FILE *stream;
+     GDB_FILE *stream;
 {
   register struct command_line *cmdlines;
 
   cmdlines = c->user_commands;
   if (!cmdlines)
     return;
-  fprintf_filtered (stream, "User command %s:\n", c->name);
+  fputs_filtered ("User command ", stream);
+  fputs_filtered (c->name, stream);
+  fputs_filtered (":\n", stream);
+
   while (cmdlines)
     {
-      fprintf_filtered (stream, "%s\n", cmdlines->line); 
+      print_command_line (cmdlines, 4, stream);
       cmdlines = cmdlines->next;
     }
   fputs_filtered ("\n", stream);
@@ -1207,14 +1543,14 @@ show_user (args, from_tty)
       c = lookup_cmd (&args, cmdlist, "", 0, 1);
       if (c->class != class_user)
 	error ("Not a user command.");
-      show_user_1 (c, stdout);
+      show_user_1 (c, gdb_stdout);
     }
   else
     {
       for (c = cmdlist; c; c = c->next)
 	{
 	  if (c->class == class_user)
-	    show_user_1 (c, stdout);
+	    show_user_1 (c, gdb_stdout);
 	}
     }
 }
@@ -1226,10 +1562,12 @@ _initialize_command ()
 	   "Execute the rest of the line as a shell command.  \n\
 With no arguments, run an inferior shell.");
 
-  add_com ("make", class_support, make_command,
-	   "Run the ``make'' program using the rest of the line as arguments.");
+  if (xdb_commands)
+    add_com_alias ("!", "shell", class_support, 0);
 
-  add_cmd ("user", no_class, show_user, 
+  add_com ("make", class_support, make_command,
+       "Run the ``make'' program using the rest of the line as arguments.");
+  add_cmd ("user", no_class, show_user,
 	   "Show definitions of user defined commands.\n\
 Argument is the name of the user defined command.\n\
 With no argument, show definitions of all user defined commands.", &showlist);