[thirdparty/binutils-gdb.git] / gdb / cli / cli-setshow.c

/* Handle set and show GDB commands.

   Copyright 2000, 2001, 2002 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 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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "value.h"
#include <ctype.h>
#include "gdb_string.h"

#include "ui-out.h"

#include "cli/cli-decode.h"
#include "cli/cli-cmds.h"
#include "cli/cli-setshow.h"

/* Prototypes for local functions */

static int parse_binary_operation (char *);

\f
static enum auto_boolean
parse_auto_binary_operation (const char *arg)
{
  if (arg != NULL && *arg != '\0')
    {
      int length = strlen (arg);
      while (isspace (arg[length - 1]) && length > 0)
	length--;
      if (strncmp (arg, "on", length) == 0
	  || strncmp (arg, "1", length) == 0
	  || strncmp (arg, "yes", length) == 0
	  || strncmp (arg, "enable", length) == 0)
	return AUTO_BOOLEAN_TRUE;
      else if (strncmp (arg, "off", length) == 0
	       || strncmp (arg, "0", length) == 0
	       || strncmp (arg, "no", length) == 0
	       || strncmp (arg, "disable", length) == 0)
	return AUTO_BOOLEAN_FALSE;
      else if (strncmp (arg, "auto", length) == 0
	       || (strncmp (arg, "-1", length) == 0 && length > 1))
	return AUTO_BOOLEAN_AUTO;
    }
  error ("\"on\", \"off\" or \"auto\" expected.");
  return AUTO_BOOLEAN_AUTO; /* pacify GCC */
}

static int
parse_binary_operation (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) == 0
      || strncmp (arg, "1", length) == 0
      || strncmp (arg, "yes", length) == 0
      || strncmp (arg, "enable", length) == 0)
    return 1;
  else if (strncmp (arg, "off", length) == 0
	   || strncmp (arg, "0", length) == 0
	   || strncmp (arg, "no", length) == 0
	   || strncmp (arg, "disable", length) == 0)
    return 0;
  else
    {
      error ("\"on\" or \"off\" expected.");
      return 0;
    }
}
\f
/* 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 (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++) != '\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 */
		    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)
	      xfree (*(char **) c->var);
	    *(char **) c->var = new;
	  }
	  break;
	case var_string_noescape:
	  if (arg == NULL)
	    arg = "";
	  if (*(char **) c->var != NULL)
	    xfree (*(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)
	    xfree (*(char **) c->var);
	  *(char **) c->var = tilde_expand (arg);
	  break;
	case var_boolean:
	  *(int *) c->var = parse_binary_operation (arg);
	  break;
	case var_auto_boolean:
	  *(enum auto_boolean *) c->var = parse_auto_binary_operation (arg);
	  break;
	case var_uinteger:
	  if (arg == NULL)
	    error_no_arg ("integer to set it to.");
	  *(unsigned int *) c->var = parse_and_eval_long (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_long (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_long (arg);
	  break;
	case var_enum:
	  {
	    int i;
	    int len;
	    int nmatches;
	    const 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)
		{
		  if (c->enums[i][len] == '\0')
		    {
		      match = c->enums[i];
		      nmatches = 1;
		      break; /* exact match. */
		    }
		  else
		    {
		      match = c->enums[i];
		      nmatches++;
		    }
		}

	    if (nmatches <= 0)
	      error ("Undefined item: \"%s\".", arg);

	    if (nmatches > 1)
	      error ("Ambiguous item \"%s\".", arg);

	    *(const char **) c->var = match;
	  }
	  break;
	default:
	  error ("gdb internal error: bad var_type in do_setshow_command");
	}
    }
  else if (c->type == show_cmd)
    {
      struct cleanup *old_chain;
      struct ui_stream *stb;
      int quote;

      stb = ui_out_stream_new (uiout);
      old_chain = make_cleanup_ui_out_stream_delete (stb);

      /* Possibly call the pre hook.  */
      if (c->pre_show_hook)
	(c->pre_show_hook) (c);

      /* Print doc minus "show" at start.  */
      print_doc_line (gdb_stdout, c->doc + 5);

      ui_out_text (uiout, " is ");
      ui_out_wrap_hint (uiout, "    ");
      quote = 0;
      switch (c->var_type)
	{
	case var_string:
	  {
	    unsigned char *p;

	    if (*(unsigned char **) c->var)
	      fputstr_filtered (*(unsigned char **) c->var, '"', stb->stream);
	    quote = 1;
	  }
	  break;
	case var_string_noescape:
	case var_filename:
	case var_enum:
	  if (*(char **) c->var)
	    fputs_filtered (*(char **) c->var, stb->stream);
	  quote = 1;
	  break;
	case var_boolean:
	  fputs_filtered (*(int *) c->var ? "on" : "off", stb->stream);
	  break;
	case var_auto_boolean:
	  switch (*(enum auto_boolean*) c->var)
	    {
	    case AUTO_BOOLEAN_TRUE:
	      fputs_filtered ("on", stb->stream);
	      break;
	    case AUTO_BOOLEAN_FALSE:
	      fputs_filtered ("off", stb->stream);
	      break;
	    case AUTO_BOOLEAN_AUTO:
	      fputs_filtered ("auto", stb->stream);
	      break;
	    default:
	      internal_error (__FILE__, __LINE__,
			      "do_setshow_command: invalid var_auto_boolean");
	      break;
	    }
	  break;
	case var_uinteger:
	  if (*(unsigned int *) c->var == UINT_MAX)
	    {
	      fputs_filtered ("unlimited", stb->stream);
	      break;
	    }
	  /* else fall through */
	case var_zinteger:
	  fprintf_filtered (stb->stream, "%u", *(unsigned int *) c->var);
	  break;
	case var_integer:
	  if (*(int *) c->var == INT_MAX)
	    {
	      fputs_filtered ("unlimited", stb->stream);
	    }
	  else
	    fprintf_filtered (stb->stream, "%d", *(int *) c->var);
	  break;

	default:
	  error ("gdb internal error: bad var_type in do_setshow_command");
	}
      if (quote)
	ui_out_text (uiout, "\"");
      ui_out_field_stream (uiout, "value", stb);
      if (quote)
	ui_out_text (uiout, "\"");
      ui_out_text (uiout, ".\n");
      do_cleanups (old_chain);
    }
  else
    error ("gdb internal error: bad cmd_type in do_setshow_command");
  c->func (c, NULL, from_tty);
  if (c->type == set_cmd && set_hook)
    set_hook (c);
}

/* Show all the settings in a list of show commands.  */

void
cmd_show_list (struct cmd_list_element *list, int from_tty, char *prefix)
{
  ui_out_tuple_begin (uiout, "showlist");
  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)
	{
	  ui_out_tuple_begin (uiout, "optionlist");
	  ui_out_field_string (uiout, "prefix", list->prefixname + 5);
	  cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5);
	  ui_out_tuple_end (uiout);
	}
      if (list->type == show_cmd)
	{
	  ui_out_tuple_begin (uiout, "option");
	  ui_out_text (uiout, prefix);
	  ui_out_field_string (uiout, "name", list->name);
	  ui_out_text (uiout, ":  ");
	  do_setshow_command ((char *) NULL, from_tty, list);
	  ui_out_tuple_end (uiout);
	}
    }
  ui_out_tuple_end (uiout);
}
Commit	Line	Data
d318976c	1	/* Handle set and show GDB commands.
8926118c AC	2
8926118c AC	3	Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
d318976c FN	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place - Suite 330,
	18	Boston, MA 02111-1307, USA. */
	19
	20	#include "defs.h"
	21	#include "value.h"
	22	#include <ctype.h>
d318976c	23	#include "gdb_string.h"
d318976c	24
d318976c	25	#include "ui-out.h"
d318976c FN	26
	27	#include "cli/cli-decode.h"
	28	#include "cli/cli-cmds.h"
	29	#include "cli/cli-setshow.h"
	30
	31	/* Prototypes for local functions */
	32
	33	static int parse_binary_operation (char *);
	34
d318976c	35	\f
7f19b9a2	36	static enum auto_boolean
d318976c FN	37	parse_auto_binary_operation (const char *arg)
	38	{
	39	if (arg != NULL && *arg != '\0')
	40	{
	41	int length = strlen (arg);
	42	while (isspace (arg[length - 1]) && length > 0)
	43	length--;
	44	if (strncmp (arg, "on", length) == 0
	45	\|\| strncmp (arg, "1", length) == 0
	46	\|\| strncmp (arg, "yes", length) == 0
	47	\|\| strncmp (arg, "enable", length) == 0)
7f19b9a2	48	return AUTO_BOOLEAN_TRUE;
d318976c FN	49	else if (strncmp (arg, "off", length) == 0
	50	\|\| strncmp (arg, "0", length) == 0
	51	\|\| strncmp (arg, "no", length) == 0
	52	\|\| strncmp (arg, "disable", length) == 0)
7f19b9a2	53	return AUTO_BOOLEAN_FALSE;
d318976c FN	54	else if (strncmp (arg, "auto", length) == 0
d318976c FN	55	\|\| (strncmp (arg, "-1", length) == 0 && length > 1))
7f19b9a2	56	return AUTO_BOOLEAN_AUTO;
d318976c FN	57	}
d318976c FN	58	error ("\"on\", \"off\" or \"auto\" expected.");
7f19b9a2	59	return AUTO_BOOLEAN_AUTO; /* pacify GCC */
d318976c FN	60	}
	61
	62	static int
	63	parse_binary_operation (char *arg)
	64	{
	65	int length;
	66
	67	if (!arg \|\| !*arg)
	68	return 1;
	69
	70	length = strlen (arg);
	71
	72	while (arg[length - 1] == ' ' \|\| arg[length - 1] == '\t')
	73	length--;
	74
	75	if (strncmp (arg, "on", length) == 0
	76	\|\| strncmp (arg, "1", length) == 0
	77	\|\| strncmp (arg, "yes", length) == 0
	78	\|\| strncmp (arg, "enable", length) == 0)
	79	return 1;
	80	else if (strncmp (arg, "off", length) == 0
	81	\|\| strncmp (arg, "0", length) == 0
	82	\|\| strncmp (arg, "no", length) == 0
	83	\|\| strncmp (arg, "disable", length) == 0)
	84	return 0;
	85	else
	86	{
	87	error ("\"on\" or \"off\" expected.");
	88	return 0;
	89	}
	90	}
	91	\f
	92	/* Do a "set" or "show" command. ARG is NULL if no argument, or the text
	93	of the argument, and FROM_TTY is nonzero if this command is being entered
	94	directly by the user (i.e. these are just like any other
	95	command). C is the command list element for the command. */
	96
	97	void
	98	do_setshow_command (char arg, int from_tty, struct cmd_list_element c)
	99	{
	100	if (c->type == set_cmd)
	101	{
	102	switch (c->var_type)
	103	{
	104	case var_string:
	105	{
	106	char *new;
	107	char *p;
	108	char *q;
	109	int ch;
	110
	111	if (arg == NULL)
	112	arg = "";
	113	new = (char *) xmalloc (strlen (arg) + 2);
	114	p = arg;
	115	q = new;
	116	while ((ch = *p++) != '\000')
	117	{
	118	if (ch == '\\')
	119	{
	120	/* \ at end of argument is used after spaces
	121	so they won't be lost. */
	122	/* This is obsolete now that we no longer strip
	123	trailing whitespace and actually, the backslash
124	didn't get here in my test, readline or
125	something did something funky with a backslash
126	right before a newline. */
127	if (*p == 0)
128	break;
129	ch = parse_escape (&p);
130	if (ch == 0)
131	break; /* C loses */
132	else if (ch > 0)
133	*q++ = ch;
134	}
135	else
136	*q++ = ch;
137	}
138	#if 0
139	if (*(p - 1) != '\\')
140	*q++ = ' ';
141	#endif
142	*q++ = '\0';
143	new = (char *) xrealloc (new, q - new);
144	if ((char *) c->var != NULL)
b8c9b27d	145	xfree ((char *) c->var);
d318976c FN	146	(char *) c->var = new;
	147	}
	148	break;
	149	case var_string_noescape:
	150	if (arg == NULL)
	151	arg = "";
	152	if ((char *) c->var != NULL)
b8c9b27d	153	xfree ((char *) c->var);
d318976c FN	154	(char *) c->var = savestring (arg, strlen (arg));
	155	break;
	156	case var_filename:
	157	if (arg == NULL)
	158	error_no_arg ("filename to set it to.");
	159	if ((char *) c->var != NULL)
b8c9b27d	160	xfree ((char *) c->var);
d318976c FN	161	(char *) c->var = tilde_expand (arg);
	162	break;
	163	case var_boolean:
	164	(int ) c->var = parse_binary_operation (arg);
	165	break;
	166	case var_auto_boolean:
7f19b9a2	167	(enum auto_boolean ) c->var = parse_auto_binary_operation (arg);
d318976c FN	168	break;
	169	case var_uinteger:
	170	if (arg == NULL)
	171	error_no_arg ("integer to set it to.");
	172	(unsigned int ) c->var = parse_and_eval_long (arg);
	173	if ((unsigned int ) c->var == 0)
	174	(unsigned int ) c->var = UINT_MAX;
	175	break;
	176	case var_integer:
	177	{
	178	unsigned int val;
	179	if (arg == NULL)
	180	error_no_arg ("integer to set it to.");
	181	val = parse_and_eval_long (arg);
	182	if (val == 0)
	183	(int ) c->var = INT_MAX;
	184	else if (val >= INT_MAX)
	185	error ("integer %u out of range", val);
	186	else
	187	(int ) c->var = val;
	188	break;
	189	}
	190	case var_zinteger:
	191	if (arg == NULL)
	192	error_no_arg ("integer to set it to.");
	193	(int ) c->var = parse_and_eval_long (arg);
	194	break;
	195	case var_enum:
	196	{
	197	int i;
	198	int len;
	199	int nmatches;
	200	const char *match = NULL;
	201	char *p;
	202
	203	/* if no argument was supplied, print an informative error message */
	204	if (arg == NULL)
	205	{
	206	char msg[1024];
	207	strcpy (msg, "Requires an argument. Valid arguments are ");
	208	for (i = 0; c->enums[i]; i++)
	209	{
	210	if (i != 0)
	211	strcat (msg, ", ");
	212	strcat (msg, c->enums[i]);
	213	}
	214	strcat (msg, ".");
	215	error (msg);
	216	}
	217
	218	p = strchr (arg, ' ');
	219
	220	if (p)
	221	len = p - arg;
	222	else
	223	len = strlen (arg);
	224
	225	nmatches = 0;
	226	for (i = 0; c->enums[i]; i++)
	227	if (strncmp (arg, c->enums[i], len) == 0)
	228	{
	229	if (c->enums[i][len] == '\0')
	230	{
	231	match = c->enums[i];
232	nmatches = 1;
233	break; /* exact match. */
234	}
235	else
236	{
237	match = c->enums[i];
238	nmatches++;
239	}
240	}
241
242	if (nmatches <= 0)
243	error ("Undefined item: \"%s\".", arg);
244
245	if (nmatches > 1)
246	error ("Ambiguous item \"%s\".", arg);
247
248	(const char *) c->var = match;
249	}
250	break;
251	default:
252	error ("gdb internal error: bad var_type in do_setshow_command");
253	}
254	}
255	else if (c->type == show_cmd)
256	{
d318976c FN	257	struct cleanup *old_chain;
	258	struct ui_stream *stb;
	259	int quote;
	260
	261	stb = ui_out_stream_new (uiout);
	262	old_chain = make_cleanup_ui_out_stream_delete (stb);
d318976c	263
552c04a7 TT	264	/* Possibly call the pre hook. */
	265	if (c->pre_show_hook)
	266	(c->pre_show_hook) (c);
	267
d318976c FN	268	/* Print doc minus "show" at start. */
	269	print_doc_line (gdb_stdout, c->doc + 5);
	270
d318976c FN	271	ui_out_text (uiout, " is ");
	272	ui_out_wrap_hint (uiout, " ");
	273	quote = 0;
	274	switch (c->var_type)
	275	{
	276	case var_string:
	277	{
	278	unsigned char *p;
	279
	280	if ((unsigned char *) c->var)
	281	fputstr_filtered ((unsigned char *) c->var, '"', stb->stream);
	282	quote = 1;
	283	}
	284	break;
	285	case var_string_noescape:
	286	case var_filename:
	287	case var_enum:
	288	if ((char *) c->var)
	289	fputs_filtered ((char *) c->var, stb->stream);
	290	quote = 1;
	291	break;
	292	case var_boolean:
	293	fputs_filtered ((int ) c->var ? "on" : "off", stb->stream);
	294	break;
	295	case var_auto_boolean:
7f19b9a2	296	switch ((enum auto_boolean) c->var)
d318976c	297	{
7f19b9a2	298	case AUTO_BOOLEAN_TRUE:
d318976c FN	299	fputs_filtered ("on", stb->stream);
d318976c FN	300	break;
7f19b9a2	301	case AUTO_BOOLEAN_FALSE:
d318976c FN	302	fputs_filtered ("off", stb->stream);
d318976c FN	303	break;
7f19b9a2	304	case AUTO_BOOLEAN_AUTO:
d318976c FN	305	fputs_filtered ("auto", stb->stream);
	306	break;
	307	default:
8e65ff28 AC	308	internal_error (__FILE__, __LINE__,
8e65ff28 AC	309	"do_setshow_command: invalid var_auto_boolean");
d318976c FN	310	break;
	311	}
	312	break;
	313	case var_uinteger:
	314	if ((unsigned int ) c->var == UINT_MAX)
	315	{
	316	fputs_filtered ("unlimited", stb->stream);
	317	break;
	318	}
	319	/* else fall through */
	320	case var_zinteger:
	321	fprintf_filtered (stb->stream, "%u", (unsigned int ) c->var);
	322	break;
	323	case var_integer:
	324	if ((int ) c->var == INT_MAX)
	325	{
	326	fputs_filtered ("unlimited", stb->stream);
	327	}
	328	else
	329	fprintf_filtered (stb->stream, "%d", (int ) c->var);
	330	break;
	331
	332	default:
	333	error ("gdb internal error: bad var_type in do_setshow_command");
	334	}
	335	if (quote)
	336	ui_out_text (uiout, "\"");
	337	ui_out_field_stream (uiout, "value", stb);
	338	if (quote)
	339	ui_out_text (uiout, "\"");
	340	ui_out_text (uiout, ".\n");
	341	do_cleanups (old_chain);
d318976c FN	342	}
	343	else
	344	error ("gdb internal error: bad cmd_type in do_setshow_command");
9f60d481	345	c->func (c, NULL, from_tty);
d318976c FN	346	if (c->type == set_cmd && set_hook)
	347	set_hook (c);
	348	}
	349
	350	/* Show all the settings in a list of show commands. */
	351
	352	void
	353	cmd_show_list (struct cmd_list_element list, int from_tty, char prefix)
	354	{
666547aa	355	ui_out_tuple_begin (uiout, "showlist");
d318976c FN	356	for (; list != NULL; list = list->next)
	357	{
	358	/* If we find a prefix, run its list, prefixing our output by its
	359	prefix (with "show " skipped). */
d318976c FN	360	if (list->prefixlist && !list->abbrev_flag)
d318976c FN	361	{
666547aa	362	ui_out_tuple_begin (uiout, "optionlist");
d318976c FN	363	ui_out_field_string (uiout, "prefix", list->prefixname + 5);
d318976c FN	364	cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5);
666547aa	365	ui_out_tuple_end (uiout);
d318976c FN	366	}
	367	if (list->type == show_cmd)
	368	{
666547aa	369	ui_out_tuple_begin (uiout, "option");
d318976c FN	370	ui_out_text (uiout, prefix);
	371	ui_out_field_string (uiout, "name", list->name);
	372	ui_out_text (uiout, ": ");
	373	do_setshow_command ((char *) NULL, from_tty, list);
666547aa	374	ui_out_tuple_end (uiout);
d318976c	375	}
d318976c	376	}
666547aa	377	ui_out_tuple_end (uiout);
d318976c FN	378	}
d318976c FN	379