Johns release

1 files changed, 1150 insertions, 0 deletions

diff --git a/gdb/command.c b/gdb/command.c
new file mode 100644
index 0000000..0b541a7
--- /dev/null
+++ b/gdb/command.c
@@ -0,0 +1,1150 @@
+/* Library for reading command lines and decoding commands.
+   Copyright (C) 1986, 1989, 1990 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 1, 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.
+
+   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.  */
+
+#include "defs.h"
+#include "command.h"
+#include "symtab.h"
+#include "value.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+extern char *getenv ();
+
+/* Add element named NAME to command list *LIST.
+   FUN should be the function to execute the command;
+   it will get a character string as argument, with leading
+   and trailing blanks already eliminated.
+
+   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.  */
+
+struct cmd_list_element *
+add_cmd (name, class, fun, doc, list)
+     char *name;
+     enum command_class class;
+     void (*fun) ();
+     char *doc;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c
+    = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+
+  delete_cmd (name, list);
+  c->next = *list;
+  c->name = name;
+  c->class = class;
+  c->function = fun;
+  c->doc = doc;
+  c->prefixlist = 0;
+  c->prefixname = (char *)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->var_type = var_boolean;
+  c->user_commands = 0;
+  *list = c;
+  return c;
+}
+
+/* Same as above, except that the abbrev_flag is set. */
+
+struct cmd_list_element *
+add_abbrev_cmd (name, class, fun, doc, list)
+     char *name;
+     enum command_class class;
+     void (*fun) ();
+     char *doc;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c
+    = add_cmd (name, class, fun, doc, list);
+
+  c->abbrev_flag = 1;
+  return c;
+}
+
+struct cmd_list_element *
+add_alias_cmd (name, oldname, class, abbrev_flag, list)
+     char *name;
+     char *oldname;
+     enum command_class class;
+     int abbrev_flag;
+     struct cmd_list_element **list;
+{
+  /* Must do this since lookup_cmd tries to side-effect its first arg */
+  char *copied_name;
+  register struct cmd_list_element *old;
+  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);
+
+  if (old == 0)
+    {
+      delete_cmd (name, list);
+      return 0;
+    }
+
+  c = add_cmd (name, class, old->function, old->doc, list);
+  c->prefixlist = old->prefixlist;
+  c->prefixname = old->prefixname;
+  c->allow_unknown = old->allow_unknown;
+  c->abbrev_flag = abbrev_flag;
+  c->aux = old->aux;
+  return c;
+}
+
+/* Like add_cmd but adds an element for a command prefix:
+   a name that should be followed by a subcommand to be looked up
+   in another command list.  PREFIXLIST should be the address
+   of the variable containing that list.  */
+
+struct cmd_list_element *
+add_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
+		allow_unknown, list)
+     char *name;
+     enum command_class class;
+     void (*fun) ();
+     char *doc;
+     struct cmd_list_element **prefixlist;
+     char *prefixname;
+     int allow_unknown;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+  c->prefixlist = prefixlist;
+  c->prefixname = prefixname;
+  c->allow_unknown = allow_unknown;
+  return c;
+}
+
+/* Like add_prefix_cmd butsets the abbrev_flag on the new command. */
+   
+struct cmd_list_element *
+add_abbrev_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
+		allow_unknown, list)
+     char *name;
+     enum command_class class;
+     void (*fun) ();
+     char *doc;
+     struct cmd_list_element **prefixlist;
+     char *prefixname;
+     int allow_unknown;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+  c->prefixlist = prefixlist;
+  c->prefixname = prefixname;
+  c->allow_unknown = allow_unknown;
+  c->abbrev_flag = 1;
+  return c;
+}
+
+void
+not_just_help_class_command (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.
+   VAR_TYPE is the kind of thing we are setting.
+   VAR is address of the variable being controlled by this command.
+   DOC is the documentation string.  */
+struct cmd_list_element *
+add_set_cmd (name, class, var_type, var, doc, list)
+     char *name;
+     enum command_class class;
+     var_types var_type;
+     char *var;
+     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);
+
+  c->type = set_cmd;
+  c->var_type = var_type;
+  c->var = var;
+  return c;
+}
+
+/* Where SETCMD has already been added, add the corresponding show
+   command to LIST and return a pointer to it.  */
+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));
+
+  bcopy (setcmd, showcmd, 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, "");
+  else
+    fprintf (stderr, "GDB internal error: Bad docstring for set command\n");
+  
+  showcmd->next = *list;
+  *list = showcmd;
+  return showcmd;
+}
+
+/* Remove the command named NAME from the command list.  */
+
+void
+delete_cmd (name, list)
+     char *name;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c;
+  struct cmd_list_element *p;
+
+  while (*list && !strcmp ((*list)->name, name))
+    {
+      p = (*list)->next;
+      free (*list);
+      *list = p;
+    }
+
+  if (*list)
+    for (c = *list; c->next;)
+      {
+	if (!strcmp (c->next->name, name))
+	  {
+	    p = c->next->next;
+	    free (c->next);
+	    c->next = p;
+	  }
+	else
+	  c = c->next;
+      }
+}
+
+void help_cmd (), help_list (), help_cmd_list ();
+
+/* This command really has to deal with two things:
+ *     1) I want documentation on *this string* (usually called by
+ * "help commandname").
+ *     2) I want documentation on *this list* (usually called by
+ * giving a command that requires subcommands.  Also called by saying
+ * just "help".)
+ *
+ *   I am going to split this into two seperate comamnds, help_cmd and
+ * help_list. 
+ */
+
+void
+help_cmd (command, stream)
+     char *command;
+     FILE *stream;
+{
+  struct cmd_list_element *c;
+  extern struct cmd_list_element *cmdlist;
+
+  if (!command)
+    {
+      help_list (cmdlist, "", all_classes, stream);
+      return;
+    }
+
+  c = lookup_cmd (&command, cmdlist, "", 0, 0);
+
+  if (c == 0)
+    return;
+
+  /* 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
+     so that the commands in the class will be listed.  */
+
+  fputs_filtered (c->doc, stream);
+  fputs_filtered ("\n", stream);
+
+  if (c->prefixlist == 0 && c->function != 0)
+    return;
+  fprintf_filtered (stream, "\n");
+
+  /* If this is a prefix command, print it's subcommands */
+  if (c->prefixlist)
+    help_list (*c->prefixlist, c->prefixname, all_commands, stream);
+
+  /* If this is a class name, print all of the commands in the class */
+  if (c->function == 0)
+    help_list (cmdlist, "", c->class, stream);
+}
+
+/*
+ * Get a specific kind of help on a command list.
+ *
+ * LIST is the list.
+ * CMDTYPE is the prefix to use in the title string.
+ * CLASS is the class with which to list the nodes of this list (see
+ * documentation for help_cmd_list below),  As usual, ALL_COMMANDS for
+ * everything, ALL_CLASSES for just classes, and non-negative for only things
+ * in a specific class.
+ * and STREAM is the output stream on which to print things.
+ * If you call this routine with a class >= 0, it recurses.
+ */
+void
+help_list (list, cmdtype, class, stream)
+     struct cmd_list_element *list;
+     char *cmdtype;
+     enum command_class class;
+     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);
+  cmdtype1[0] = 0;
+  cmdtype2 = (char *) alloca (len + 4);
+  cmdtype2[0] = 0;
+  if (len)
+    {
+      cmdtype1[0] = ' ';
+      strncpy (cmdtype1 + 1, cmdtype, len - 1);
+      cmdtype1[len] = 0;
+      strncpy (cmdtype2, cmdtype, len - 1);
+      strcpy (cmdtype2 + len - 1, " sub");
+    }
+
+  if (class == all_classes)
+    fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2);
+  else
+    fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2);
+
+  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);
+
+  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);
+}
+     
+/* Print only the first line of STR on STREAM.  */
+static void
+print_doc_line (stream, str)
+     FILE *stream;
+     char *str;
+{
+  static char *line_buffer = 0;
+  static int line_size;
+  register char *p;
+
+  if (!line_buffer)
+    {
+      line_size = 80;
+      line_buffer = (char *) xmalloc (line_size);
+    }
+
+  p = str;
+  while (*p && *p != '\n' && *p != '.' && *p != ',')
+    p++;
+  if (p - str > line_size - 1)
+    {
+      line_size = p - str + 1;
+      free (line_buffer);
+      line_buffer = (char *) xmalloc (line_size);
+    }
+  strncpy (line_buffer, str, p - str);
+  line_buffer[p - str] = '\0';
+  if (islower (line_buffer[0]))
+    line_buffer[0] = toupper (line_buffer[0]);
+  fputs_filtered (line_buffer, stream);
+}
+
+/*
+ * Implement a help command on command list LIST.
+ * RECURSE should be non-zero if this should be done recursively on
+ * all sublists of LIST.
+ * 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
+ * class.
+ *	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 seclected by the criteria above (ie. the selection mechanism
+ * is at the low level, not the high-level).
+ */
+void
+help_cmd_list (list, class, prefix, recurse, stream)
+     struct cmd_list_element *list;
+     enum command_class class;
+     char *prefix;
+     int recurse;
+     FILE *stream;
+{
+  register struct cmd_list_element *c;
+
+  for (c = list; c; c = c->next)
+    {
+      if (c->abbrev_flag == 0 &&
+	  (class == all_commands
+	  || (class == all_classes && c->function == 0)
+	  || (class == c->class && c->function != 0)))
+	{
+	  fprintf_filtered (stream, "%s%s -- ", prefix, c->name);
+	  print_doc_line (stream, c->doc);
+	  fputs_filtered ("\n", stream);
+	}
+      if (recurse
+	  && c->prefixlist != 0
+	  && c->abbrev_flag == 0)
+	help_cmd_list (*c->prefixlist, class, c->prefixname, 1, 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).
+
+   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.
+
+   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).  */
+
+struct cmd_list_element *
+lookup_cmd_1 (text, clist, result_list, ignore_help_classes)
+     char **text;
+     struct cmd_list_element *clist, **result_list;
+     int ignore_help_classes;
+{
+  char *p, *command;
+  int len, tmp, nfound;
+  struct cmd_list_element *found, *c;
+
+  while (**text == ' ' || **text == '\t')
+    (*text)++;
+
+  /* Treating underscores as part of command words is important
+     so that "set args_foo()" doesn't get interpreted as
+     "set args _foo()".  */
+  for (p = *text;
+       *p && (isalnum(*p) || *p == '-' || *p == '_');
+       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.  */
+
+  command = (char *) alloca (len + 1);
+  for (tmp = 0; tmp < len; tmp++)
+    {
+      char x = (*text)[tmp];
+      command[tmp] = (x >= 'A' && x <= 'Z') ? x - 'A' + 'a' : 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))
+      {
+	found = c;
+	nfound++;
+	if (c->name[len] == '\0')
+	  {
+	    nfound = 1;
+	    break;
+	  }
+      }
+
+  /* If nothing matches, we have a simple failure.  */
+  if (nfound == 0)
+    return 0;
+
+  if (nfound > 1)
+    {
+      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.  */
+    }
+
+  /* We've matched something on this list.  Move text pointer forward. */
+
+  *text = p;
+  if (found->prefixlist)
+    {
+      c = lookup_cmd_1 (text, *found->prefixlist, result_list,
+			ignore_help_classes);
+      if (!c)
+	{
+	  /* Didn't find anything; this is as far as we got.  */
+	  if (result_list != NULL)
+	    *result_list = clist;
+	  return found;
+	}
+      else if (c == (struct cmd_list_element *) -1)
+	{
+	  /* We've gotten this far properley, 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.  */
+	      *result_list = found;
+	  return c;
+	}
+      else
+	{
+	  /* We matched!  */
+	  return c;
+	}
+    }
+  else
+    {
+      if (result_list != NULL)
+	*result_list = clist;
+      return found;
+    }
+}
+
+/* Look up the contents of *LINE as a command in the command list LIST.
+   LIST is a chain of struct cmd_list_element's.
+   If it is found, return the struct cmd_list_element for that command
+   and update *LINE to point after the command name, at the first argument.
+   If not found, call error if ALLOW_UNKNOWN is zero
+   otherwise (or if error returns) return zero.
+   Call error if specified command is ambiguous,
+   unless ALLOW_UNKNOWN is negative.
+   CMDTYPE precedes the word "command" in the error message.
+
+   If INGNORE_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).  */
+
+struct cmd_list_element *
+lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes)
+     char **line;
+     struct cmd_list_element *list;
+     char *cmdtype;
+     int allow_unknown;
+     int 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);
+  char *ptr = (*line) + strlen (*line) - 1;
+
+  /* Clear off trailing whitespace.  */
+  while (ptr >= *line && (*ptr == ' ' || *ptr == '\t'))
+    ptr--;
+  *(ptr + 1) = '\0';
+  
+  if (!c)
+    {
+      if (!allow_unknown)
+	{
+	  if (!*line)
+	    error ("Lack of needed %scommand", cmdtype);
+	  else
+	    {
+	      char *p = *line, *q;
+
+	      while (isalnum(*p) || *p == '-')
+		p++;
+
+	      q = (char *) alloca (p - *line + 1);
+	      strncpy (q, *line, p - *line);
+	      q[p-*line] = '\0';
+	      
+	      error ("Undefined %scommand: \"%s\".", cmdtype, q);
+	    }
+	}
+      else
+	return 0;
+    }
+  else if (c == (struct cmd_list_element *) -1)
+    {
+      /* Ambigous.  Local values should be off prefixlist or called
+	 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);
+      
+      if (local_allow_unknown < 0)
+	{
+	  if (last_list)
+	    return last_list;	/* Found something.  */
+	  else
+	    return 0;		/* Found nothing.  */
+	}
+      else
+	{
+	  /* Report as error.  */
+	  int amb_len;
+	  char ambbuf[100];
+
+	  for (amb_len = 0;
+	       ((*line)[amb_len] && (*line)[amb_len] != ' '
+		&& (*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))
+		      strcat (ambbuf, ", ");
+		    strcat (ambbuf, c->name);
+		  }
+		else
+		  {
+		    strcat (ambbuf, "..");
+		    break;
+		  }
+	      }
+	  error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype,
+		 *line, ambbuf);
+	  return 0;		/* lint */
+	}
+    }
+  else
+    {
+      /* We've got something.  It may still not be what the caller
+         wants (if this command *needs* a subcommand).  */
+      while (**line == ' ' || **line == '\t')
+	(*line)++;
+
+      if (c->prefixlist && **line && !c->allow_unknown)
+	error ("Undefined %scommand: \"%s\".", c->prefixname, *line);
+
+      /* Seems to be what he wants.  Return it.  */
+      return c;
+    }
+  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.
+   If it is found, return the struct cmd_list_element for that command
+   and update *LINE to point after the command name, at the first argument.
+   If not found, call error if ALLOW_UNKNOWN is zero
+   otherwise (or if error returns) return zero.
+   Call error if specified command is ambiguous,
+   unless ALLOW_UNKNOWN is negative.
+   CMDTYPE precedes the word "command" in the error message.  */
+
+struct cmd_list_element *
+lookup_cmd (line, list, cmdtype, allow_unknown)
+     char **line;
+     struct cmd_list_element *list;
+     char *cmdtype;
+     int allow_unknown;
+{
+  register char *p;
+  register struct cmd_list_element *c, *found;
+  int nfound;
+  char ambbuf[100];
+  char *processed_cmd;
+  int i, cmd_len;
+
+  /* Skip leading whitespace.  */
+
+  while (**line == ' ' || **line == '\t')
+    (*line)++;
+
+  /* Clear out trailing whitespace.  */
+
+  p = *line + strlen (*line);
+  while (p != *line && (p[-1] == ' ' || p[-1] == '\t'))
+    p--;
+  *p = 0;
+
+  /* Find end of command name.  */
+
+  p = *line;
+  while (*p == '-'
+	 || (*p >= 'a' && *p <= 'z')
+	 || (*p >= 'A' && *p <= 'Z')
+	 || (*p >= '0' && *p <= '9'))
+    p++;
+
+  /* Look up the command name.
+     If exact match, keep that.
+     Otherwise, take command abbreviated, if unique.  Note that (in my
+     opinion) a null string does *not* indicate ambiguity; simply the
+     end of the argument.  */
+
+  if (p == *line)
+    {
+      if (!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 (x >= 'A' && x <= 'Z')
+	processed_cmd[cmd_len] = x - 'A' + 'a';
+      else
+	processed_cmd[cmd_len] = x;
+    }
+  processed_cmd[cmd_len] = '\0';
+
+  /* Check all possibilities in the current command list.  */
+  found = 0;
+  nfound = 0;
+  for (c = list; c; c = c->next)
+    {
+      if (!strncmp (processed_cmd, c->name, cmd_len))
+	{
+	  found = c;
+	  nfound++;
+	  if (c->name[cmd_len] == 0)
+	    {
+	      nfound = 1;
+	      break;
+	    }
+	}
+    }
+
+  /* Report error for undefined command name.  */
+
+  if (nfound != 1)
+    {
+      if (nfound > 1 && allow_unknown >= 0)
+	{
+	  ambbuf[0] = 0;
+	  for (c = list; c; c = c->next)
+	    if (!strncmp (processed_cmd, c->name, cmd_len))
+	      {
+		if (strlen (ambbuf) + strlen (c->name) + 6 < sizeof ambbuf)
+		  {
+		    if (strlen (ambbuf))
+		      strcat (ambbuf, ", ");
+		    strcat (ambbuf, c->name);
+		  }
+		else
+		  {
+		    strcat (ambbuf, "..");
+		    break;
+		  }
+	      }
+	  error ("Ambiguous %scommand \"%s\": %s.", cmdtype,
+		 processed_cmd, ambbuf);
+	}
+      else if (!allow_unknown)
+	error ("Undefined %scommand: \"%s\".", cmdtype, processed_cmd);
+      return 0;
+    }
+
+  /* Skip whitespace before the argument.  */
+
+  while (*p == ' ' || *p == '\t') p++;
+  *line = p;
+
+  if (found->prefixlist && *p)
+    {
+      c = lookup_cmd (line, *found->prefixlist, found->prefixname,
+		      found->allow_unknown);
+      if (c)
+	return c;
+    }
+
+  return found;
+}
+#endif
+
+/* Helper function for SYMBOL_COMPLETION_FUNCTION.  */
+
+/* Return a vector of char pointers which point to the different
+   possible completions in LIST of TEXT.  */
+
+char **
+complete_on_cmdlist (list, text)
+     struct cmd_list_element *list;
+     char *text;
+{
+  struct cmd_list_element *ptr;
+  char **matchlist;
+  int sizeof_matchlist;
+  int matches;
+  int textlen = strlen (text);
+
+  sizeof_matchlist = 10;
+  matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *));
+  matches = 0;
+
+  for (ptr = list; ptr; ptr = ptr->next)
+    if (!strncmp (ptr->name, text, textlen)
+	&& !ptr->abbrev_flag
+	&& (ptr->function
+	    || ptr->prefixlist))
+      {
+	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);
+      }
+
+  if (matches == 0)
+    {
+      free (matchlist);
+      matchlist = 0;
+    }
+  else
+    {
+      matchlist = (char **) xrealloc ((char *)matchlist, ((matches + 1)
+						* sizeof (char *)));
+      matchlist[matches] = (char *) 0;
+    }
+
+  return matchlist;
+}
+
+static int
+parse_binary_operation (arg)
+     char *arg;
+{
+  int length;
+
+  if (!arg || !*arg)
+    return 1;
+
+  length = strlen (arg);
+
+  while (arg[length - 1] == ' ' || arg[length - 1] == '\t')
+    length--;
+
+  if (!strncmp (arg, "on", length)
+      || !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 
+      {
+	error ("\"on\" or \"off\" expected.");
+	return 0;
+      }
+}
+
+/* Do a "set" or "show" command.  ARG is NULL if no argument, or the text
+   of the argument, and FROM_TTY is nonzero if this command is being entered
+   directly by the user (i.e. these are just like any other
+   command).  C is the command list element for the command.  */
+void
+do_setshow_command (arg, from_tty, c)
+     char *arg;
+     int from_tty;
+     struct cmd_list_element *c;
+{
+  if (c->type == set_cmd)
+    {
+      switch (c->var_type)
+	{
+	case var_string:
+	  {
+	    char *new;
+	    char *p;
+	    char *q;
+	    int ch;
+	    
+	    if (arg == NULL)
+	      arg = "";
+	    new = (char *) xmalloc (strlen (arg) + 2);
+	    p = arg; q = new;
+	    while (ch = *p++)
+	      {
+		if (ch == '\\')
+		  {
+		    /* \ at end of argument is used after spaces
+		       so they won't be lost.  */
+		    if (*p == 0)
+		      break;
+		    ch = parse_escape (&p);
+		    if (ch == 0)
+		      break; /* C loses */
+		    else if (ch > 0)
+		      *q++ = ch;
+		  }
+		else
+		  *q++ = ch;
+	      }
+	    if (*(p - 1) != '\\')
+	      *q++ = ' ';
+	    *q++ = '\0';
+	    new = (char *) xrealloc (new, q - new);
+	    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);
+	  *(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);
+	  break;
+	case var_boolean:
+	  *(int *) c->var = parse_binary_operation (arg);
+	  break;
+	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;
+	  break;
+	case var_zinteger:
+	  if (arg == NULL)
+	    error_no_arg ("integer to set it to.");
+	  *(int *) c->var = parse_and_eval_address (arg);
+	  break;
+	default:
+	  error ("gdb internal error: bad var_type in do_setshow_command");
+	}
+    }
+  else if (c->type == show_cmd)
+    {
+      /* Print doc minus "show" at start.  */
+      print_doc_line (stdout, c->doc + 5);
+      
+      fputs_filtered (" is ", 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);
+	  break;
+	}
+	/* 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);
+    }
+  else
+    error ("gdb internal error: bad cmd_type in do_setshow_command");
+  (*c->function) (NULL, from_tty, c);
+}
+
+/* Show all the settings in a list of show commands.  */
+
+void
+cmd_show_list (list, from_tty, prefix)
+     struct cmd_list_element *list;
+     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);
+      }
+  }
+}
+
+static void
+shell_escape (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  int rc, status, pid;
+  char *p, *user_shell;
+  extern char *rindex ();
+
+  if ((user_shell = (char *) getenv ("SHELL")) == NULL)
+    user_shell = "/bin/sh";
+
+  /* Get the name of the shell for arg0 */
+  if ((p = rindex (user_shell, '/')) == NULL)
+    p = user_shell;
+  else
+    p++;			/* Get past '/' */
+
+  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);
+    }
+
+  if (pid != -1)
+    while ((rc = wait (&status)) != pid && rc != -1)
+      ;
+  else
+    error ("Fork failed");
+}
+
+static void
+make_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  char *p;
+
+  if (arg == 0)
+    p = "make";
+  else
+    {
+      p = xmalloc (sizeof("make ") + strlen(arg));
+      strcpy (p, "make ");
+      strcpy (p + sizeof("make ")-1, arg);
+    }
+  
+  shell_escape (p, from_tty);
+}
+
+void
+_initialize_command ()
+{
+  add_com ("shell", class_support, shell_escape,
+	   "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.");
+}