-/* Library for reading command lines and decoding commands.
- Copyright (C) 1986, 1989, 1990 Free Software Foundation, Inc.
+/* Handle lists of commands, their decoding and documentation, for GDB.
+ Copyright 1986, 1989, 1990, 1991 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
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
#include "defs.h"
-#include "param.h"
-#include "command.h"
+#include "gdbcmd.h"
#include "symtab.h"
#include "value.h"
#include <ctype.h>
#include <string.h>
-extern char *getenv ();
+/* Prototypes for local functions */
-/* Add element named NAME to command list *LIST.
+static void
+undef_cmd_error PARAMS ((char *, char *));
+
+static void
+show_user PARAMS ((char *, int));
+
+static void
+show_user_1 PARAMS ((struct cmd_list_element *, FILE *));
+
+static void
+make_command PARAMS ((char *, int));
+
+static void
+shell_escape PARAMS ((char *, int));
+
+static int
+parse_binary_operation PARAMS ((char *));
+
+static void
+print_doc_line PARAMS ((FILE *, char *));
+
+/* 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.
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. */
struct cmd_list_element *
add_cmd (name, class, fun, doc, list)
char *name;
enum command_class class;
- void (*fun) ();
+ void (*fun) PARAMS ((char *, int));
char *doc;
struct cmd_list_element **list;
{
c->next = *list;
c->name = name;
c->class = class;
- c->function = fun;
+ c->function.cfunc = fun;
c->doc = doc;
c->prefixlist = 0;
c->prefixname = (char *)NULL;
c->allow_unknown = 0;
+ c->hook = 0;
+ c->hookee = 0;
+ c->cmd_pointer = 0;
c->abbrev_flag = 0;
- c->aux = 0;
c->type = not_set_cmd;
c->completer = make_symbol_completion_list;
c->var = 0;
/* Same as above, except that the abbrev_flag is set. */
+#if 0 /* Currently unused */
+
struct cmd_list_element *
add_abbrev_cmd (name, class, fun, doc, list)
char *name;
enum command_class class;
- void (*fun) ();
+ void (*fun) PARAMS ((char *, int));
char *doc;
struct cmd_list_element **list;
{
return c;
}
+#endif
+
struct cmd_list_element *
add_alias_cmd (name, oldname, class, abbrev_flag, list)
char *name;
return 0;
}
- c = add_cmd (name, class, old->function, old->doc, list);
+ c = add_cmd (name, class, old->function.cfunc, 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;
+ c->cmd_pointer = old;
return c;
}
allow_unknown, list)
char *name;
enum command_class class;
- void (*fun) ();
+ void (*fun) PARAMS ((char *, int));
char *doc;
struct cmd_list_element **prefixlist;
char *prefixname;
return c;
}
-/* Like add_prefix_cmd butsets the abbrev_flag on the new command. */
+/* 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)
+ allow_unknown, list)
char *name;
enum command_class class;
- void (*fun) ();
+ void (*fun) PARAMS ((char *, int));
char *doc;
struct cmd_list_element **prefixlist;
char *prefixname;
/* ARGSUSED */
void
-not_just_help_class_command (args, from_tty, c)
+not_just_help_class_command (args, from_tty)
char *args;
int from_tty;
- struct cmd_list_element *c;
{
}
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;
struct cmd_list_element *showcmd =
(struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
- 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, "");
+ showcmd->doc = concat ("Show ", setcmd->doc + 4, NULL);
else
fprintf (stderr, "GDB internal error: Bad docstring for set command\n");
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 (*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 (c->next);
+ free ((PTR)c->next);
c->next = p;
}
else
fputs_filtered (c->doc, stream);
fputs_filtered ("\n", stream);
- if (c->prefixlist == 0 && c->function != 0)
+ if (c->prefixlist == 0 && c->function.cfunc != NULL)
return;
fprintf_filtered (stream, "\n");
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)
+ 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);
}
/*
if (p - str > line_size - 1)
{
line_size = p - str + 1;
- free (line_buffer);
+ free ((PTR)line_buffer);
line_buffer = (char *) xmalloc (line_size);
}
strncpy (line_buffer, str, p - str);
* 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
+ * ones selected by the criteria above (ie. the selection mechanism
* is at the low level, not the high-level).
*/
void
{
if (c->abbrev_flag == 0 &&
(class == all_commands
- || (class == all_classes && c->function == 0)
- || (class == c->class && c->function != 0)))
+ || (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);
}
}
\f
-/* 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).
+/* 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.
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)
for (tmp = 0; tmp < len; tmp++)
{
char x = (*text)[tmp];
- command[tmp] = (x >= 'A' && x <= 'Z') ? x - 'A' + 'a' : x;
+ command[tmp] = isupper(x) ? tolower(x) : x;
}
command[len] = '\0';
nfound = 0;
for (c = clist; c; c = c->next)
if (!strncmp (command, c->name, len)
- && (!ignore_help_classes || c->function))
+ && (!ignore_help_classes || c->function.cfunc))
{
found = c;
nfound++;
/* 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,
/* All this hair to move the space to the front of cmdtype */
-void
+static void
undef_cmd_error (cmdtype, q)
char *cmdtype, *q;
{
/* Find end of command name. */
p = *line;
- while (*p == '-'
- || (*p >= 'a' && *p <= 'z')
- || (*p >= 'A' && *p <= 'Z')
- || (*p >= '0' && *p <= '9'))
+ while (*p == '-' || isalnum(*p))
p++;
/* Look up the command name.
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';
+ if (isupper(x))
+ processed_cmd[cmd_len] = tolower(x);
else
processed_cmd[cmd_len] = x;
}
for (ptr = list; ptr; ptr = ptr->next)
if (!strncmp (ptr->name, text, textlen)
&& !ptr->abbrev_flag
- && (ptr->function
+ && (ptr->function.cfunc
|| ptr->prefixlist))
{
if (matches == sizeof_matchlist)
if (matches == 0)
{
- free (matchlist);
+ free ((PTR)matchlist);
matchlist = 0;
}
else
arg = "";
new = (char *) xmalloc (strlen (arg) + 2);
p = arg; q = new;
- while (ch = *p++)
+ while ((ch = *p++) != '\000')
{
if (ch == '\\')
{
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.");
unsigned char *p;
fputs_filtered ("\"", stdout);
for (p = *(unsigned char **) c->var; *p != '\0'; p++)
- printchar (*p, stdout, '"');
+ gdb_printchar (*p, stdout, '"');
fputs_filtered ("\"", stdout);
}
break;
}
/* else fall through */
case var_zinteger:
- fprintf_filtered (stdout, "%d", *(unsigned int *) c->var);
+ fprintf_filtered (stdout, "%u", *(unsigned int *) c->var);
+ break;
+ case var_integer:
+ if (*(int *) c->var == INT_MAX)
+ {
+ fputs_filtered ("unlimited", stdout);
+ }
+ else
+ fprintf_filtered (stdout, "%d", *(int *) c->var);
break;
+
default:
error ("gdb internal error: bad var_type in do_setshow_command");
}
}
else
error ("gdb internal error: bad cmd_type in do_setshow_command");
- (*c->function) (NULL, from_tty, c);
+ (*c->function.sfunc) (NULL, from_tty, c);
}
/* Show all the settings in a list of show commands. */
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;
- 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)
+ if ((p = strrchr (user_shell, '/')) == NULL)
p = user_shell;
else
p++; /* Get past '/' */
;
else
error ("Fork failed");
+#endif /* Can fork. */
}
static void
}
static void
-user_info_1 (c, stream)
+show_user_1 (c, stream)
struct cmd_list_element *c;
FILE *stream;
{
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);
+ fputs_filtered (cmdlines->line, stream);
+ fputs_filtered ("\n", stream);
cmdlines = cmdlines->next;
}
fputs_filtered ("\n", stream);
/* ARGSUSED */
static void
-user_info (args, from_tty)
+show_user (args, from_tty)
char *args;
int from_tty;
{
c = lookup_cmd (&args, cmdlist, "", 0, 1);
if (c->class != class_user)
error ("Not a user command.");
- user_info_1 (c, stdout);
+ show_user_1 (c, stdout);
}
else
{
for (c = cmdlist; c; c = c->next)
{
if (c->class == class_user)
- user_info_1 (c, stdout);
+ show_user_1 (c, stdout);
}
}
}
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.");
-
- add_info ("user", user_info, "Show definitions of user defined commands.\n\
+ 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.");
+With no argument, show definitions of all user defined commands.", &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff