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

/* Handle set and show GDB commands.

   Copyright (c) 2000, 2001, 2002, 2003, 2007 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., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include "defs.h"
#include "readline/tilde.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
void
deprecated_show_value_hack (struct ui_file *ignore_file,
			    int ignore_from_tty,
			    struct cmd_list_element *c,
			    const char *value)
{
  /* If there's no command or value, don't try to print it out.  */
  if (c == NULL || value == NULL)
    return;
  /* Print doc minus "show" at start.  */
  print_doc_line (gdb_stdout, c->doc + 5);
  switch (c->var_type)
    {
    case var_string:
    case var_string_noescape:
    case var_optional_filename:
    case var_filename:
    case var_enum:
      printf_filtered ((" is \"%s\".\n"), value);
      break;
    default:
      printf_filtered ((" is %s.\n"), value);
      break;
    }
}

/* 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_optional_filename:
	  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 (("%s"), 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;

      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);

      switch (c->var_type)
	{
	case var_string:
	  if (*(char **) c->var)
	    fputstr_filtered (*(char **) c->var, '"', stb->stream);
	  break;
	case var_string_noescape:
	case var_optional_filename:
	case var_filename:
	case var_enum:
	  if (*(char **) c->var)
	    fputs_filtered (*(char **) c->var, stb->stream);
	  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"));
	}


      /* FIXME: cagney/2005-02-10: Need to split this in half: code to
	 convert the value into a string (esentially the above); and
	 code to print the value out.  For the latter there should be
	 MI and CLI specific versions.  */

      if (ui_out_is_mi_like_p (uiout))
	ui_out_field_stream (uiout, "value", stb);
      else
	{
	  long length;
	  char *value = ui_file_xstrdup (stb->stream, &length);
	  make_cleanup (xfree, value);
	  if (c->show_value_func != NULL)
	    c->show_value_func (gdb_stdout, from_tty, c, value);
	  else
	    deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
	}
      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 && deprecated_set_hook)
    deprecated_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)
{
  struct cleanup *showlist_chain;

  showlist_chain = make_cleanup_ui_out_tuple_begin_end (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)
	{
	  struct cleanup *optionlist_chain
	    = make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
	  char *new_prefix = strstr (list->prefixname, "show ") + 5;
	  if (ui_out_is_mi_like_p (uiout))
	    ui_out_field_string (uiout, "prefix", new_prefix);
	  cmd_show_list (*list->prefixlist, from_tty, new_prefix);
	  /* Close the tuple.  */
	  do_cleanups (optionlist_chain);
	}
      else
	{
	  struct cleanup *option_chain
	    = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
	  ui_out_text (uiout, prefix);
	  ui_out_field_string (uiout, "name", list->name);
	  ui_out_text (uiout, ":  ");
	  if (list->type == show_cmd)
	    do_setshow_command ((char *) NULL, from_tty, list);
	  else
	    cmd_func (list, NULL, from_tty);
          /* Close the tuple.  */
	  do_cleanups (option_chain);
	}
    }
  /* Close the tuple.  */
  do_cleanups (showlist_chain);
}
Commit	Line	Data
d318976c	1	/* Handle set and show GDB commands.
8926118c	2
6aba47ca	3	Copyright (c) 2000, 2001, 2002, 2003, 2007 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
10f9c213 EZ	17	Foundation, Inc., 51 Franklin Street, Fifth Floor,
10f9c213 EZ	18	Boston, MA 02110-1301, USA. */
d318976c FN	19
d318976c FN	20	#include "defs.h"
dbda9972	21	#include "readline/tilde.h"
d318976c FN	22	#include "value.h"
d318976c FN	23	#include <ctype.h>
d318976c	24	#include "gdb_string.h"
d318976c	25
d318976c	26	#include "ui-out.h"
d318976c FN	27
	28	#include "cli/cli-decode.h"
	29	#include "cli/cli-cmds.h"
	30	#include "cli/cli-setshow.h"
	31
	32	/* Prototypes for local functions */
	33
	34	static int parse_binary_operation (char *);
	35
d318976c	36	\f
7f19b9a2	37	static enum auto_boolean
d318976c FN	38	parse_auto_binary_operation (const char *arg)
	39	{
	40	if (arg != NULL && *arg != '\0')
	41	{
	42	int length = strlen (arg);
	43	while (isspace (arg[length - 1]) && length > 0)
	44	length--;
	45	if (strncmp (arg, "on", length) == 0
	46	\|\| strncmp (arg, "1", length) == 0
	47	\|\| strncmp (arg, "yes", length) == 0
	48	\|\| strncmp (arg, "enable", length) == 0)
7f19b9a2	49	return AUTO_BOOLEAN_TRUE;
d318976c FN	50	else if (strncmp (arg, "off", length) == 0
	51	\|\| strncmp (arg, "0", length) == 0
	52	\|\| strncmp (arg, "no", length) == 0
	53	\|\| strncmp (arg, "disable", length) == 0)
7f19b9a2	54	return AUTO_BOOLEAN_FALSE;
d318976c FN	55	else if (strncmp (arg, "auto", length) == 0
d318976c FN	56	\|\| (strncmp (arg, "-1", length) == 0 && length > 1))
7f19b9a2	57	return AUTO_BOOLEAN_AUTO;
d318976c	58	}
8a3fe4f8	59	error (_("\"on\", \"off\" or \"auto\" expected."));
7f19b9a2	60	return AUTO_BOOLEAN_AUTO; /* pacify GCC */
d318976c FN	61	}
	62
	63	static int
	64	parse_binary_operation (char *arg)
	65	{
	66	int length;
	67
	68	if (!arg \|\| !*arg)
	69	return 1;
	70
	71	length = strlen (arg);
	72
	73	while (arg[length - 1] == ' ' \|\| arg[length - 1] == '\t')
	74	length--;
	75
	76	if (strncmp (arg, "on", length) == 0
	77	\|\| strncmp (arg, "1", length) == 0
	78	\|\| strncmp (arg, "yes", length) == 0
	79	\|\| strncmp (arg, "enable", length) == 0)
	80	return 1;
	81	else if (strncmp (arg, "off", length) == 0
	82	\|\| strncmp (arg, "0", length) == 0
	83	\|\| strncmp (arg, "no", length) == 0
	84	\|\| strncmp (arg, "disable", length) == 0)
	85	return 0;
	86	else
	87	{
8a3fe4f8	88	error (_("\"on\" or \"off\" expected."));
d318976c FN	89	return 0;
	90	}
	91	}
	92	\f
08546159 AC	93	void
	94	deprecated_show_value_hack (struct ui_file *ignore_file,
	95	int ignore_from_tty,
	96	struct cmd_list_element *c,
	97	const char *value)
	98	{
4d28ad1e AC	99	/* If there's no command or value, don't try to print it out. */
	100	if (c == NULL \|\| value == NULL)
	101	return;
08546159 AC	102	/* Print doc minus "show" at start. */
	103	print_doc_line (gdb_stdout, c->doc + 5);
	104	switch (c->var_type)
	105	{
	106	case var_string:
	107	case var_string_noescape:
b4b4ac0b	108	case var_optional_filename:
08546159 AC	109	case var_filename:
	110	case var_enum:
	111	printf_filtered ((" is \"%s\".\n"), value);
	112	break;
	113	default:
	114	printf_filtered ((" is %s.\n"), value);
	115	break;
	116	}
	117	}
	118
d318976c FN	119	/* Do a "set" or "show" command. ARG is NULL if no argument, or the text
	120	of the argument, and FROM_TTY is nonzero if this command is being entered
	121	directly by the user (i.e. these are just like any other
	122	command). C is the command list element for the command. */
	123
	124	void
	125	do_setshow_command (char arg, int from_tty, struct cmd_list_element c)
	126	{
	127	if (c->type == set_cmd)
	128	{
	129	switch (c->var_type)
	130	{
	131	case var_string:
	132	{
	133	char *new;
	134	char *p;
	135	char *q;
	136	int ch;
	137
	138	if (arg == NULL)
	139	arg = "";
	140	new = (char *) xmalloc (strlen (arg) + 2);
	141	p = arg;
	142	q = new;
	143	while ((ch = *p++) != '\000')
	144	{
	145	if (ch == '\\')
	146	{
	147	/* \ at end of argument is used after spaces
	148	so they won't be lost. */
	149	/* This is obsolete now that we no longer strip
	150	trailing whitespace and actually, the backslash
	151	didn't get here in my test, readline or
	152	something did something funky with a backslash
	153	right before a newline. */
	154	if (*p == 0)
	155	break;
	156	ch = parse_escape (&p);
	157	if (ch == 0)
	158	break; /* C loses */
	159	else if (ch > 0)
	160	*q++ = ch;
	161	}
	162	else
	163	*q++ = ch;
	164	}
	165	#if 0
	166	if (*(p - 1) != '\\')
	167	*q++ = ' ';
	168	#endif
	169	*q++ = '\0';
	170	new = (char *) xrealloc (new, q - new);
	171	if ((char *) c->var != NULL)
b8c9b27d	172	xfree ((char *) c->var);
d318976c FN	173	(char *) c->var = new;
	174	}
	175	break;
	176	case var_string_noescape:
	177	if (arg == NULL)
	178	arg = "";
	179	if ((char *) c->var != NULL)
b8c9b27d	180	xfree ((char *) c->var);
d318976c FN	181	(char *) c->var = savestring (arg, strlen (arg));
d318976c FN	182	break;
b4b4ac0b	183	case var_optional_filename:
d318976c	184	if (arg == NULL)
525226b5 AC	185	arg = "";
	186	if ((char *) c->var != NULL)
	187	xfree ((char *) c->var);
	188	(char *) c->var = savestring (arg, strlen (arg));
	189	break;
	190	case var_filename:
	191	if (arg == NULL)
	192	error_no_arg (_("filename to set it to."));
d318976c	193	if ((char *) c->var != NULL)
b8c9b27d	194	xfree ((char *) c->var);
d318976c FN	195	(char *) c->var = tilde_expand (arg);
	196	break;
	197	case var_boolean:
	198	(int ) c->var = parse_binary_operation (arg);
	199	break;
	200	case var_auto_boolean:
7f19b9a2	201	(enum auto_boolean ) c->var = parse_auto_binary_operation (arg);
d318976c FN	202	break;
	203	case var_uinteger:
	204	if (arg == NULL)
e2e0b3e5	205	error_no_arg (_("integer to set it to."));
d318976c FN	206	(unsigned int ) c->var = parse_and_eval_long (arg);
	207	if ((unsigned int ) c->var == 0)
	208	(unsigned int ) c->var = UINT_MAX;
	209	break;
	210	case var_integer:
	211	{
	212	unsigned int val;
	213	if (arg == NULL)
e2e0b3e5	214	error_no_arg (_("integer to set it to."));
d318976c FN	215	val = parse_and_eval_long (arg);
	216	if (val == 0)
	217	(int ) c->var = INT_MAX;
	218	else if (val >= INT_MAX)
8a3fe4f8	219	error (_("integer %u out of range"), val);
d318976c FN	220	else
	221	(int ) c->var = val;
	222	break;
	223	}
	224	case var_zinteger:
	225	if (arg == NULL)
e2e0b3e5	226	error_no_arg (_("integer to set it to."));
d318976c FN	227	(int ) c->var = parse_and_eval_long (arg);
	228	break;
	229	case var_enum:
	230	{
	231	int i;
	232	int len;
	233	int nmatches;
	234	const char *match = NULL;
	235	char *p;
	236
	237	/* if no argument was supplied, print an informative error message */
	238	if (arg == NULL)
	239	{
	240	char msg[1024];
	241	strcpy (msg, "Requires an argument. Valid arguments are ");
	242	for (i = 0; c->enums[i]; i++)
	243	{
	244	if (i != 0)
	245	strcat (msg, ", ");
	246	strcat (msg, c->enums[i]);
	247	}
	248	strcat (msg, ".");
8a3fe4f8	249	error (("%s"), msg);
d318976c FN	250	}
	251
	252	p = strchr (arg, ' ');
	253
	254	if (p)
	255	len = p - arg;
	256	else
	257	len = strlen (arg);
	258
	259	nmatches = 0;
	260	for (i = 0; c->enums[i]; i++)
	261	if (strncmp (arg, c->enums[i], len) == 0)
	262	{
	263	if (c->enums[i][len] == '\0')
	264	{
	265	match = c->enums[i];
	266	nmatches = 1;
	267	break; /* exact match. */
	268	}
	269	else
	270	{
	271	match = c->enums[i];
	272	nmatches++;
	273	}
	274	}
	275
	276	if (nmatches <= 0)
8a3fe4f8	277	error (_("Undefined item: \"%s\"."), arg);
d318976c FN	278
d318976c FN	279	if (nmatches > 1)
8a3fe4f8	280	error (_("Ambiguous item \"%s\"."), arg);
d318976c FN	281
	282	(const char *) c->var = match;
	283	}
	284	break;
	285	default:
8a3fe4f8	286	error (_("gdb internal error: bad var_type in do_setshow_command"));
d318976c FN	287	}
	288	}
	289	else if (c->type == show_cmd)
	290	{
d318976c FN	291	struct cleanup *old_chain;
d318976c FN	292	struct ui_stream *stb;
d318976c FN	293
	294	stb = ui_out_stream_new (uiout);
	295	old_chain = make_cleanup_ui_out_stream_delete (stb);
d318976c	296
552c04a7 TT	297	/* Possibly call the pre hook. */
	298	if (c->pre_show_hook)
	299	(c->pre_show_hook) (c);
	300
d318976c FN	301	switch (c->var_type)
	302	{
	303	case var_string:
3b113db7 DJ	304	if ((char *) c->var)
3b113db7 DJ	305	fputstr_filtered ((char *) c->var, '"', stb->stream);
d318976c FN	306	break;
d318976c FN	307	case var_string_noescape:
b4b4ac0b	308	case var_optional_filename:
d318976c FN	309	case var_filename:
	310	case var_enum:
	311	if ((char *) c->var)
	312	fputs_filtered ((char *) c->var, stb->stream);
d318976c FN	313	break;
	314	case var_boolean:
	315	fputs_filtered ((int ) c->var ? "on" : "off", stb->stream);
	316	break;
	317	case var_auto_boolean:
7f19b9a2	318	switch ((enum auto_boolean) c->var)
d318976c	319	{
7f19b9a2	320	case AUTO_BOOLEAN_TRUE:
d318976c FN	321	fputs_filtered ("on", stb->stream);
d318976c FN	322	break;
7f19b9a2	323	case AUTO_BOOLEAN_FALSE:
d318976c FN	324	fputs_filtered ("off", stb->stream);
d318976c FN	325	break;
7f19b9a2	326	case AUTO_BOOLEAN_AUTO:
d318976c FN	327	fputs_filtered ("auto", stb->stream);
	328	break;
	329	default:
8e65ff28	330	internal_error (__FILE__, __LINE__,
e2e0b3e5	331	_("do_setshow_command: invalid var_auto_boolean"));
d318976c FN	332	break;
	333	}
	334	break;
	335	case var_uinteger:
	336	if ((unsigned int ) c->var == UINT_MAX)
	337	{
	338	fputs_filtered ("unlimited", stb->stream);
	339	break;
	340	}
	341	/* else fall through */
	342	case var_zinteger:
	343	fprintf_filtered (stb->stream, "%u", (unsigned int ) c->var);
	344	break;
	345	case var_integer:
	346	if ((int ) c->var == INT_MAX)
	347	{
	348	fputs_filtered ("unlimited", stb->stream);
	349	}
	350	else
	351	fprintf_filtered (stb->stream, "%d", (int ) c->var);
	352	break;
	353
	354	default:
8a3fe4f8	355	error (_("gdb internal error: bad var_type in do_setshow_command"));
d318976c	356	}
899506a8 AC	357
	358
	359	/* FIXME: cagney/2005-02-10: Need to split this in half: code to
	360	convert the value into a string (esentially the above); and
	361	code to print the value out. For the latter there should be
	362	MI and CLI specific versions. */
	363
	364	if (ui_out_is_mi_like_p (uiout))
	365	ui_out_field_stream (uiout, "value", stb);
08546159	366	else
335cca0d AC	367	{
	368	long length;
	369	char *value = ui_file_xstrdup (stb->stream, &length);
	370	make_cleanup (xfree, value);
08546159 AC	371	if (c->show_value_func != NULL)
	372	c->show_value_func (gdb_stdout, from_tty, c, value);
	373	else
	374	deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
899506a8	375	}
d318976c	376	do_cleanups (old_chain);
d318976c FN	377	}
d318976c FN	378	else
8a3fe4f8	379	error (_("gdb internal error: bad cmd_type in do_setshow_command"));
9f60d481	380	c->func (c, NULL, from_tty);
9a4105ab AC	381	if (c->type == set_cmd && deprecated_set_hook)
9a4105ab AC	382	deprecated_set_hook (c);
d318976c FN	383	}
	384
	385	/* Show all the settings in a list of show commands. */
	386
	387	void
	388	cmd_show_list (struct cmd_list_element list, int from_tty, char prefix)
	389	{
3b31d625 EZ	390	struct cleanup *showlist_chain;
	391
	392	showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
d318976c FN	393	for (; list != NULL; list = list->next)
	394	{
	395	/* If we find a prefix, run its list, prefixing our output by its
	396	prefix (with "show " skipped). */
d318976c FN	397	if (list->prefixlist && !list->abbrev_flag)
d318976c FN	398	{
3b31d625 EZ	399	struct cleanup *optionlist_chain
3b31d625 EZ	400	= make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
37fc812e DJ	401	char *new_prefix = strstr (list->prefixname, "show ") + 5;
	402	if (ui_out_is_mi_like_p (uiout))
	403	ui_out_field_string (uiout, "prefix", new_prefix);
	404	cmd_show_list (*list->prefixlist, from_tty, new_prefix);
3b31d625 EZ	405	/* Close the tuple. */
3b31d625 EZ	406	do_cleanups (optionlist_chain);
d318976c	407	}
427c3a89	408	else
d318976c	409	{
3b31d625 EZ	410	struct cleanup *option_chain
3b31d625 EZ	411	= make_cleanup_ui_out_tuple_begin_end (uiout, "option");
d318976c FN	412	ui_out_text (uiout, prefix);
	413	ui_out_field_string (uiout, "name", list->name);
	414	ui_out_text (uiout, ": ");
427c3a89 DJ	415	if (list->type == show_cmd)
	416	do_setshow_command ((char *) NULL, from_tty, list);
	417	else
	418	cmd_func (list, NULL, from_tty);
3b31d625 EZ	419	/* Close the tuple. */
3b31d625 EZ	420	do_cleanups (option_chain);
d318976c	421	}
d318976c	422	}
3b31d625 EZ	423	/* Close the tuple. */
3b31d625 EZ	424	do_cleanups (showlist_chain);
d318976c FN	425	}
d318976c FN	426