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

/* Handle set and show GDB commands.

   Copyright (C) 2000-2013 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "readline/tilde.h"
#include "value.h"
#include <ctype.h>
#include "gdb_string.h"
#include "arch-utils.h"
#include "observer.h"

#include "ui-out.h"

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

/* Return true if the change of command parameter should be notified.  */

static int
notify_command_param_changed_p (int param_changed, struct cmd_list_element *c)
{
  if (param_changed == 0)
    return 0;

  if (c->class == class_maintenance || c->class == class_deprecated
      || c->class == class_obscure)
    return 0;

  return 1;
}

\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.  */
}

/* See cli-setshow.h.  */

int
parse_cli_boolean_value (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
    return -1;
}
\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" 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_set_command (char *arg, int from_tty, struct cmd_list_element *c)
{
  /* A flag to indicate the option is changed or not.  */
  int option_changed = 0;

  gdb_assert (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 (get_current_arch (), &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
	    || strcmp (*(char **) c->var, new) != 0)
	  {
	    xfree (*(char **) c->var);
	    *(char **) c->var = new;

	    option_changed = 1;
	  }
	else
	  xfree (new);
      }
      break;
    case var_string_noescape:
      if (arg == NULL)
	arg = "";

      if (*(char **) c->var == NULL || strcmp (*(char **) c->var, arg) != 0)
	{
	  xfree (*(char **) c->var);
	  *(char **) c->var = xstrdup (arg);

	  option_changed = 1;
	}
      break;
    case var_filename:
      if (arg == NULL)
	error_no_arg (_("filename to set it to."));
      /* FALLTHROUGH */
    case var_optional_filename:
      {
	char *val = NULL;

	if (arg != NULL)
	  {
	    /* Clear trailing whitespace of filename.  */
	    char *ptr = arg + strlen (arg) - 1;

	    while (ptr >= arg && (*ptr == ' ' || *ptr == '\t'))
	      ptr--;
	    *(ptr + 1) = '\0';

	    val = tilde_expand (arg);
	  }
	else
	  val = xstrdup ("");

	if (*(char **) c->var == NULL
	    || strcmp (*(char **) c->var, val) != 0)
	  {
	    xfree (*(char **) c->var);
	    *(char **) c->var = val;

	    option_changed = 1;
	  }
	else
	  xfree (val);
      }
      break;
    case var_boolean:
      {
	int val = parse_cli_boolean_value (arg);

	if (val < 0)
	  error (_("\"on\" or \"off\" expected."));
	if (val != *(int *) c->var)
	  {
	    *(int *) c->var = val;

	    option_changed = 1;
	  }
      }
      break;
    case var_auto_boolean:
      {
	enum auto_boolean val = parse_auto_binary_operation (arg);

	if (*(enum auto_boolean *) c->var != val)
	  {
	    *(enum auto_boolean *) c->var = val;

	    option_changed = 1;
	  }
      }
      break;
    case var_uinteger:
    case var_zuinteger:
      {
	LONGEST val;

	if (arg == NULL)
	  error_no_arg (_("integer to set it to."));
	val = parse_and_eval_long (arg);

	if (c->var_type == var_uinteger && val == 0)
	  val = UINT_MAX;
	else if (val > UINT_MAX)
	  error (_("integer %s out of range"), plongest (val));

	if (*(unsigned int *) c->var != val)
	  {
	    *(unsigned int *) c->var = val;

	    option_changed = 1;
	  }
      }
      break;
    case var_integer:
    case var_zinteger:
      {
	LONGEST val;

	if (arg == NULL)
	  error_no_arg (_("integer to set it to."));
	val = parse_and_eval_long (arg);

	if (val == 0 && c->var_type == var_integer)
	  val = INT_MAX;
	else if (val > INT_MAX || val < INT_MIN)
	  error (_("integer %s out of range"), plongest (val));

	if (*(int *) c->var != val)
	  {
	    *(int *) c->var = val;

	    option_changed = 1;
	  }
	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;
	    int msg_len = 0;

	    for (i = 0; c->enums[i]; i++)
	      msg_len += strlen (c->enums[i]) + 2;

	    msg = xmalloc (msg_len);
	    *msg = '\0';
	    make_cleanup (xfree, msg);

	    for (i = 0; c->enums[i]; i++)
	      {
		if (i != 0)
		  strcat (msg, ", ");
		strcat (msg, c->enums[i]);
	      }
	    error (_("Requires an argument. Valid arguments are %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);

	if (*(const char **) c->var != match)
	  {
	    *(const char **) c->var = match;

	    option_changed = 1;
	  }
      }
      break;
    case var_zuinteger_unlimited:
      {
	LONGEST val;

	if (arg == NULL)
	  error_no_arg (_("integer to set it to."));
	val = parse_and_eval_long (arg);

	if (val > INT_MAX)
	  error (_("integer %s out of range"), plongest (val));
	else if (val < -1)
	  error (_("only -1 is allowed to set as unlimited"));

	if (*(int *) c->var != val)
	  {
	    *(int *) c->var = val;
	    option_changed = 1;
	  }
      }
      break;
    default:
      error (_("gdb internal error: bad var_type in do_setshow_command"));
    }
  c->func (c, NULL, from_tty);
  if (deprecated_set_hook)
    deprecated_set_hook (c);

  if (notify_command_param_changed_p (option_changed, c))
    {
      char *name, *cp;
      struct cmd_list_element **cmds;
      struct cmd_list_element *p;
      int i;
      int length = 0;

      /* Compute the whole multi-word command options.  If user types command
	 'set foo bar baz on', c->name is 'baz', and GDB can't pass "bar" to
	 command option change notification, because it is confusing.  We can
	 trace back through field 'prefix' to compute the whole options,
	 and pass "foo bar baz" to notification.  */

      for (i = 0, p = c; p != NULL; i++)
	{
	  length += strlen (p->name);
	  length++;

	  p = p->prefix;
	}
      cp = name = xmalloc (length);
      cmds = xmalloc (sizeof (struct cmd_list_element *) * i);

      /* Track back through filed 'prefix' and cache them in CMDS.  */
      for (i = 0, p = c; p != NULL; i++)
	{
	  cmds[i] = p;
	  p = p->prefix;
	}

      /* Don't trigger any observer notification if prefixlist is not
	 setlist.  */
      i--;
      if (cmds[i]->prefixlist != &setlist)
	{
	  xfree (cmds);
	  xfree (name);

	  return;
	}
      /* Traverse them in the reversed order, and copy their names into
	 NAME.  */
      for (i--; i >= 0; i--)
	{
	  memcpy (cp, cmds[i]->name, strlen (cmds[i]->name));
	  cp += strlen (cmds[i]->name);

	  if (i != 0)
	    {
	      cp[0] = ' ';
	      cp++;
	    }
	}
      cp[0] = 0;

      xfree (cmds);

      switch (c->var_type)
	{
	case var_string:
	case var_string_noescape:
	case var_filename:
	case var_optional_filename:
	case var_enum:
	  observer_notify_command_param_changed (name, *(char **) c->var);
	  break;
	case var_boolean:
	  {
	    char *opt = *(int *) c->var ? "on" : "off";

	    observer_notify_command_param_changed (name, opt);
	  }
	  break;
	case var_auto_boolean:
	  {
	    const char *s = auto_boolean_enums[*(enum auto_boolean *) c->var];

	    observer_notify_command_param_changed (name, s);
	  }
	  break;
	case var_uinteger:
	case var_zuinteger:
	  {
	    char s[64];

	    xsnprintf (s, sizeof s, "%u", *(unsigned int *) c->var);
	    observer_notify_command_param_changed (name, s);
	  }
	  break;
	case var_integer:
	case var_zinteger:
	case var_zuinteger_unlimited:
	  {
	    char s[64];

	    xsnprintf (s, sizeof s, "%d", *(int *) c->var);
	    observer_notify_command_param_changed (name, s);
	  }
	  break;
	}
      xfree (name);
    }
}

/* Do a "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_show_command (char *arg, int from_tty, struct cmd_list_element *c)
{
  struct ui_out *uiout = current_uiout;
  struct cleanup *old_chain;
  struct ui_file *stb;

  gdb_assert (c->type == show_cmd);

  stb = mem_fileopen ();
  old_chain = make_cleanup_ui_file_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);
      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);
      break;
    case var_boolean:
      fputs_filtered (*(int *) c->var ? "on" : "off", stb);
      break;
    case var_auto_boolean:
      switch (*(enum auto_boolean*) c->var)
	{
	case AUTO_BOOLEAN_TRUE:
	  fputs_filtered ("on", stb);
	  break;
	case AUTO_BOOLEAN_FALSE:
	  fputs_filtered ("off", stb);
	  break;
	case AUTO_BOOLEAN_AUTO:
	  fputs_filtered ("auto", stb);
	  break;
	default:
	  internal_error (__FILE__, __LINE__,
			  _("do_show_command: "
			    "invalid var_auto_boolean"));
	  break;
	}
      break;
    case var_uinteger:
    case var_zuinteger:
      if (c->var_type == var_uinteger
	  && *(unsigned int *) c->var == UINT_MAX)
	fputs_filtered ("unlimited", stb);
      else
	fprintf_filtered (stb, "%u", *(unsigned int *) c->var);
      break;
    case var_integer:
    case var_zinteger:
      if (c->var_type == var_integer
	  && *(int *) c->var == INT_MAX)
	fputs_filtered ("unlimited", stb);
      else
	fprintf_filtered (stb, "%d", *(int *) c->var);
      break;
    case var_zuinteger_unlimited:
      {
	if (*(int *) c->var == -1)
	  fputs_filtered ("unlimited", stb);
	else
	  fprintf_filtered (stb, "%d", *(int *) c->var);
      }
      break;
    default:
      error (_("gdb internal error: bad var_type in do_show_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
    {
      char *value = ui_file_xstrdup (stb, NULL);

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

  c->func (c, NULL, from_tty);
}

/* 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;
  struct ui_out *uiout = current_uiout;

  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
	{
	  if (list->class != no_set_class)
	    {
	      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_show_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
0b1afbb3	3	Copyright (C) 2000-2013 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
a9762ec7	7	the Free Software Foundation; either version 3 of the License, or
d318976c FN	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
a9762ec7	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
d318976c FN	17
d318976c FN	18	#include "defs.h"
dbda9972	19	#include "readline/tilde.h"
d318976c FN	20	#include "value.h"
d318976c FN	21	#include <ctype.h>
d318976c	22	#include "gdb_string.h"
f870a310	23	#include "arch-utils.h"
5b9afe8a	24	#include "observer.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
5b9afe8a YQ	32	/* Return true if the change of command parameter should be notified. */
	33
	34	static int
	35	notify_command_param_changed_p (int param_changed, struct cmd_list_element *c)
	36	{
	37	if (param_changed == 0)
	38	return 0;
	39
	40	if (c->class == class_maintenance \|\| c->class == class_deprecated
	41	\|\| c->class == class_obscure)
	42	return 0;
	43
	44	return 1;
	45	}
	46
d318976c	47	\f
7f19b9a2	48	static enum auto_boolean
d318976c FN	49	parse_auto_binary_operation (const char *arg)
	50	{
	51	if (arg != NULL && *arg != '\0')
	52	{
	53	int length = strlen (arg);
cdb27c12	54
d318976c FN	55	while (isspace (arg[length - 1]) && length > 0)
	56	length--;
	57	if (strncmp (arg, "on", length) == 0
	58	\|\| strncmp (arg, "1", length) == 0
	59	\|\| strncmp (arg, "yes", length) == 0
	60	\|\| strncmp (arg, "enable", length) == 0)
7f19b9a2	61	return AUTO_BOOLEAN_TRUE;
d318976c FN	62	else if (strncmp (arg, "off", length) == 0
	63	\|\| strncmp (arg, "0", length) == 0
	64	\|\| strncmp (arg, "no", length) == 0
	65	\|\| strncmp (arg, "disable", length) == 0)
7f19b9a2	66	return AUTO_BOOLEAN_FALSE;
d318976c FN	67	else if (strncmp (arg, "auto", length) == 0
d318976c FN	68	\|\| (strncmp (arg, "-1", length) == 0 && length > 1))
7f19b9a2	69	return AUTO_BOOLEAN_AUTO;
d318976c	70	}
8a3fe4f8	71	error (_("\"on\", \"off\" or \"auto\" expected."));
ebcd3b23	72	return AUTO_BOOLEAN_AUTO; /* Pacify GCC. */
d318976c FN	73	}
d318976c FN	74
bd712aed DE	75	/* See cli-setshow.h. */
	76
	77	int
	78	parse_cli_boolean_value (char *arg)
d318976c FN	79	{
	80	int length;
	81
	82	if (!arg \|\| !*arg)
	83	return 1;
	84
	85	length = strlen (arg);
	86
	87	while (arg[length - 1] == ' ' \|\| arg[length - 1] == '\t')
	88	length--;
	89
	90	if (strncmp (arg, "on", length) == 0
	91	\|\| strncmp (arg, "1", length) == 0
	92	\|\| strncmp (arg, "yes", length) == 0
	93	\|\| strncmp (arg, "enable", length) == 0)
	94	return 1;
	95	else if (strncmp (arg, "off", length) == 0
	96	\|\| strncmp (arg, "0", length) == 0
	97	\|\| strncmp (arg, "no", length) == 0
	98	\|\| strncmp (arg, "disable", length) == 0)
	99	return 0;
	100	else
bd712aed	101	return -1;
d318976c FN	102	}
d318976c FN	103	\f
08546159 AC	104	void
	105	deprecated_show_value_hack (struct ui_file *ignore_file,
	106	int ignore_from_tty,
	107	struct cmd_list_element *c,
	108	const char *value)
	109	{
4d28ad1e AC	110	/* If there's no command or value, don't try to print it out. */
	111	if (c == NULL \|\| value == NULL)
	112	return;
08546159 AC	113	/* Print doc minus "show" at start. */
	114	print_doc_line (gdb_stdout, c->doc + 5);
	115	switch (c->var_type)
	116	{
	117	case var_string:
	118	case var_string_noescape:
b4b4ac0b	119	case var_optional_filename:
08546159 AC	120	case var_filename:
	121	case var_enum:
	122	printf_filtered ((" is \"%s\".\n"), value);
	123	break;
	124	default:
	125	printf_filtered ((" is %s.\n"), value);
	126	break;
	127	}
	128	}
	129
5b9afe8a	130	/* Do a "set" command. ARG is NULL if no argument, or the
ebcd3b23 MS	131	text of the argument, and FROM_TTY is nonzero if this command is
	132	being entered directly by the user (i.e. these are just like any
	133	other command). C is the command list element for the command. */
d318976c FN	134
d318976c FN	135	void
5b9afe8a	136	do_set_command (char arg, int from_tty, struct cmd_list_element c)
d318976c	137	{
5b9afe8a YQ	138	/* A flag to indicate the option is changed or not. */
	139	int option_changed = 0;
	140
	141	gdb_assert (c->type == set_cmd);
79a45e25	142
5b9afe8a	143	switch (c->var_type)
d318976c	144	{
5b9afe8a YQ	145	case var_string:
	146	{
	147	char *new;
	148	char *p;
	149	char *q;
	150	int ch;
	151
	152	if (arg == NULL)
	153	arg = "";
	154	new = (char *) xmalloc (strlen (arg) + 2);
	155	p = arg;
	156	q = new;
	157	while ((ch = *p++) != '\000')
d318976c	158	{
5b9afe8a	159	if (ch == '\\')
d318976c	160	{
5b9afe8a YQ	161	/* \ at end of argument is used after spaces
	162	so they won't be lost. */
	163	/* This is obsolete now that we no longer strip
	164	trailing whitespace and actually, the backslash
	165	didn't get here in my test, readline or
	166	something did something funky with a backslash
	167	right before a newline. */
	168	if (*p == 0)
	169	break;
	170	ch = parse_escape (get_current_arch (), &p);
	171	if (ch == 0)
	172	break; /* C loses */
	173	else if (ch > 0)
d318976c FN	174	*q++ = ch;
d318976c FN	175	}
5b9afe8a YQ	176	else
	177	*q++ = ch;
	178	}
d318976c	179	#if 0
5b9afe8a YQ	180	if (*(p - 1) != '\\')
5b9afe8a YQ	181	*q++ = ' ';
d318976c	182	#endif
5b9afe8a YQ	183	*q++ = '\0';
	184	new = (char *) xrealloc (new, q - new);
	185
	186	if ((char *) c->var == NULL
	187	\|\| strcmp ((char *) c->var, new) != 0)
	188	{
c24343e2	189	xfree ((char *) c->var);
d318976c	190	(char *) c->var = new;
5b9afe8a YQ	191
5b9afe8a YQ	192	option_changed = 1;
d318976c	193	}
5b9afe8a YQ	194	else
	195	xfree (new);
	196	}
	197	break;
	198	case var_string_noescape:
	199	if (arg == NULL)
	200	arg = "";
	201
	202	if ((char ) c->var == NULL \|\| strcmp ((char **) c->var, arg) != 0)
	203	{
c24343e2	204	xfree ((char *) c->var);
1b36a34b	205	(char *) c->var = xstrdup (arg);
cdb27c12	206
5b9afe8a YQ	207	option_changed = 1;
	208	}
	209	break;
	210	case var_filename:
	211	if (arg == NULL)
	212	error_no_arg (_("filename to set it to."));
	213	/* FALLTHROUGH */
	214	case var_optional_filename:
	215	{
	216	char *val = NULL;
6ace3df1	217
5b9afe8a YQ	218	if (arg != NULL)
	219	{
	220	/* Clear trailing whitespace of filename. */
	221	char *ptr = arg + strlen (arg) - 1;
6ace3df1	222
5b9afe8a YQ	223	while (ptr >= arg && (ptr == ' ' \|\| ptr == '\t'))
	224	ptr--;
	225	*(ptr + 1) = '\0';
	226
	227	val = tilde_expand (arg);
	228	}
	229	else
	230	val = xstrdup ("");
	231
	232	if ((char *) c->var == NULL
	233	\|\| strcmp ((char *) c->var, val) != 0)
d318976c	234	{
5b9afe8a YQ	235	xfree ((char *) c->var);
	236	(char *) c->var = val;
	237
	238	option_changed = 1;
d318976c	239	}
5b9afe8a YQ	240	else
	241	xfree (val);
	242	}
	243	break;
	244	case var_boolean:
	245	{
bd712aed	246	int val = parse_cli_boolean_value (arg);
5b9afe8a	247
bd712aed DE	248	if (val < 0)
bd712aed DE	249	error (_("\"on\" or \"off\" expected."));
5b9afe8a YQ	250	if (val != (int ) c->var)
	251	{
	252	(int ) c->var = val;
	253
	254	option_changed = 1;
	255	}
	256	}
	257	break;
	258	case var_auto_boolean:
	259	{
	260	enum auto_boolean val = parse_auto_binary_operation (arg);
	261
	262	if ((enum auto_boolean ) c->var != val)
	263	{
	264	(enum auto_boolean ) c->var = val;
	265
	266	option_changed = 1;
	267	}
	268	}
	269	break;
	270	case var_uinteger:
	271	case var_zuinteger:
5b9afe8a	272	{
ef0026f0 PA	273	LONGEST val;
	274
	275	if (arg == NULL)
	276	error_no_arg (_("integer to set it to."));
	277	val = parse_and_eval_long (arg);
5b9afe8a YQ	278
	279	if (c->var_type == var_uinteger && val == 0)
	280	val = UINT_MAX;
ef0026f0 PA	281	else if (val > UINT_MAX)
ef0026f0 PA	282	error (_("integer %s out of range"), plongest (val));
5b9afe8a YQ	283
	284	if ((unsigned int ) c->var != val)
	285	{
	286	(unsigned int ) c->var = val;
	287
	288	option_changed = 1;
	289	}
	290	}
	291	break;
	292	case var_integer:
	293	case var_zinteger:
	294	{
ef0026f0	295	LONGEST val;
5b9afe8a YQ	296
	297	if (arg == NULL)
	298	error_no_arg (_("integer to set it to."));
	299	val = parse_and_eval_long (arg);
ef0026f0	300
5b9afe8a YQ	301	if (val == 0 && c->var_type == var_integer)
5b9afe8a YQ	302	val = INT_MAX;
ef0026f0 PA	303	else if (val > INT_MAX \|\| val < INT_MIN)
ef0026f0 PA	304	error (_("integer %s out of range"), plongest (val));
5b9afe8a YQ	305
5b9afe8a YQ	306	if ((int ) c->var != val)
d318976c	307	{
5b9afe8a YQ	308	(int ) c->var = val;
	309
	310	option_changed = 1;
	311	}
	312	break;
	313	}
	314	case var_enum:
	315	{
	316	int i;
	317	int len;
	318	int nmatches;
	319	const char *match = NULL;
	320	char *p;
	321
	322	/* If no argument was supplied, print an informative error
	323	message. */
	324	if (arg == NULL)
	325	{
	326	char *msg;
	327	int msg_len = 0;
	328
	329	for (i = 0; c->enums[i]; i++)
	330	msg_len += strlen (c->enums[i]) + 2;
	331
	332	msg = xmalloc (msg_len);
	333	*msg = '\0';
	334	make_cleanup (xfree, msg);
	335
	336	for (i = 0; c->enums[i]; i++)
d318976c	337	{
5b9afe8a YQ	338	if (i != 0)
	339	strcat (msg, ", ");
	340	strcat (msg, c->enums[i]);
d318976c	341	}
5b9afe8a YQ	342	error (_("Requires an argument. Valid arguments are %s."),
	343	msg);
	344	}
d318976c	345
5b9afe8a	346	p = strchr (arg, ' ');
d318976c	347
5b9afe8a YQ	348	if (p)
	349	len = p - arg;
	350	else
	351	len = strlen (arg);
d318976c	352
5b9afe8a YQ	353	nmatches = 0;
	354	for (i = 0; c->enums[i]; i++)
	355	if (strncmp (arg, c->enums[i], len) == 0)
	356	{
	357	if (c->enums[i][len] == '\0')
	358	{
	359	match = c->enums[i];
	360	nmatches = 1;
	361	break; /* Exact match. */
	362	}
	363	else
d318976c	364	{
5b9afe8a YQ	365	match = c->enums[i];
5b9afe8a YQ	366	nmatches++;
d318976c	367	}
5b9afe8a	368	}
d318976c	369
5b9afe8a YQ	370	if (nmatches <= 0)
5b9afe8a YQ	371	error (_("Undefined item: \"%s\"."), arg);
d318976c	372
5b9afe8a YQ	373	if (nmatches > 1)
5b9afe8a YQ	374	error (_("Ambiguous item \"%s\"."), arg);
d318976c	375
5b9afe8a YQ	376	if ((const char *) c->var != match)
5b9afe8a YQ	377	{
d318976c	378	(const char *) c->var = match;
5b9afe8a YQ	379
5b9afe8a YQ	380	option_changed = 1;
d318976c	381	}
5b9afe8a YQ	382	}
5b9afe8a YQ	383	break;
6fc1c773 YQ	384	case var_zuinteger_unlimited:
	385	{
	386	LONGEST val;
	387
	388	if (arg == NULL)
	389	error_no_arg (_("integer to set it to."));
	390	val = parse_and_eval_long (arg);
	391
ef0026f0	392	if (val > INT_MAX)
6fc1c773 YQ	393	error (_("integer %s out of range"), plongest (val));
	394	else if (val < -1)
	395	error (_("only -1 is allowed to set as unlimited"));
	396
	397	if ((int ) c->var != val)
	398	{
	399	(int ) c->var = val;
	400	option_changed = 1;
	401	}
	402	}
	403	break;
5b9afe8a YQ	404	default:
5b9afe8a YQ	405	error (_("gdb internal error: bad var_type in do_setshow_command"));
d318976c	406	}
5b9afe8a YQ	407	c->func (c, NULL, from_tty);
	408	if (deprecated_set_hook)
	409	deprecated_set_hook (c);
	410
	411	if (notify_command_param_changed_p (option_changed, c))
d318976c	412	{
5b9afe8a YQ	413	char name, cp;
	414	struct cmd_list_element **cmds;
	415	struct cmd_list_element *p;
	416	int i;
	417	int length = 0;
	418
	419	/* Compute the whole multi-word command options. If user types command
	420	'set foo bar baz on', c->name is 'baz', and GDB can't pass "bar" to
	421	command option change notification, because it is confusing. We can
	422	trace back through field 'prefix' to compute the whole options,
	423	and pass "foo bar baz" to notification. */
	424
	425	for (i = 0, p = c; p != NULL; i++)
	426	{
	427	length += strlen (p->name);
	428	length++;
	429
	430	p = p->prefix;
	431	}
	432	cp = name = xmalloc (length);
	433	cmds = xmalloc (sizeof (struct cmd_list_element ) i);
	434
	435	/* Track back through filed 'prefix' and cache them in CMDS. */
	436	for (i = 0, p = c; p != NULL; i++)
	437	{
	438	cmds[i] = p;
	439	p = p->prefix;
	440	}
	441
	442	/* Don't trigger any observer notification if prefixlist is not
	443	setlist. */
	444	i--;
	445	if (cmds[i]->prefixlist != &setlist)
	446	{
	447	xfree (cmds);
	448	xfree (name);
	449
	450	return;
	451	}
	452	/* Traverse them in the reversed order, and copy their names into
	453	NAME. */
	454	for (i--; i >= 0; i--)
	455	{
	456	memcpy (cp, cmds[i]->name, strlen (cmds[i]->name));
	457	cp += strlen (cmds[i]->name);
d318976c	458
5b9afe8a YQ	459	if (i != 0)
	460	{
	461	cp[0] = ' ';
	462	cp++;
	463	}
	464	}
	465	cp[0] = 0;
d318976c	466
5b9afe8a	467	xfree (cmds);
552c04a7	468
d318976c FN	469	switch (c->var_type)
	470	{
	471	case var_string:
d318976c FN	472	case var_string_noescape:
d318976c FN	473	case var_filename:
5b9afe8a	474	case var_optional_filename:
d318976c	475	case var_enum:
5b9afe8a	476	observer_notify_command_param_changed (name, (char *) c->var);
d318976c FN	477	break;
d318976c FN	478	case var_boolean:
5b9afe8a YQ	479	{
	480	char opt = (int *) c->var ? "on" : "off";
	481
	482	observer_notify_command_param_changed (name, opt);
	483	}
d318976c FN	484	break;
d318976c FN	485	case var_auto_boolean:
5b9afe8a YQ	486	{
	487	const char s = auto_boolean_enums[(enum auto_boolean *) c->var];
	488
	489	observer_notify_command_param_changed (name, s);
	490	}
d318976c FN	491	break;
d318976c FN	492	case var_uinteger:
1e8fb976	493	case var_zuinteger:
5b9afe8a YQ	494	{
	495	char s[64];
	496
	497	xsnprintf (s, sizeof s, "%u", (unsigned int ) c->var);
	498	observer_notify_command_param_changed (name, s);
	499	}
d318976c FN	500	break;
d318976c FN	501	case var_integer:
a40a111f	502	case var_zinteger:
6fc1c773	503	case var_zuinteger_unlimited:
5b9afe8a YQ	504	{
5b9afe8a YQ	505	char s[64];
d318976c	506
5b9afe8a YQ	507	xsnprintf (s, sizeof s, "%d", (int ) c->var);
	508	observer_notify_command_param_changed (name, s);
	509	}
	510	break;
d318976c	511	}
5b9afe8a YQ	512	xfree (name);
	513	}
	514	}
899506a8	515
5b9afe8a YQ	516	/* Do a "show" command. ARG is NULL if no argument, or the
	517	text of the argument, and FROM_TTY is nonzero if this command is
	518	being entered directly by the user (i.e. these are just like any
	519	other command). C is the command list element for the command. */
899506a8	520
5b9afe8a YQ	521	void
	522	do_show_command (char arg, int from_tty, struct cmd_list_element c)
	523	{
	524	struct ui_out *uiout = current_uiout;
	525	struct cleanup *old_chain;
	526	struct ui_file *stb;
899506a8	527
5b9afe8a YQ	528	gdb_assert (c->type == show_cmd);
	529
	530	stb = mem_fileopen ();
	531	old_chain = make_cleanup_ui_file_delete (stb);
cdb27c12	532
5b9afe8a YQ	533	/* Possibly call the pre hook. */
	534	if (c->pre_show_hook)
	535	(c->pre_show_hook) (c);
	536
	537	switch (c->var_type)
	538	{
	539	case var_string:
	540	if ((char *) c->var)
	541	fputstr_filtered ((char *) c->var, '"', stb);
	542	break;
	543	case var_string_noescape:
	544	case var_optional_filename:
	545	case var_filename:
	546	case var_enum:
	547	if ((char *) c->var)
	548	fputs_filtered ((char *) c->var, stb);
	549	break;
	550	case var_boolean:
	551	fputs_filtered ((int ) c->var ? "on" : "off", stb);
	552	break;
	553	case var_auto_boolean:
	554	switch ((enum auto_boolean) c->var)
	555	{
	556	case AUTO_BOOLEAN_TRUE:
	557	fputs_filtered ("on", stb);
	558	break;
	559	case AUTO_BOOLEAN_FALSE:
	560	fputs_filtered ("off", stb);
	561	break;
	562	case AUTO_BOOLEAN_AUTO:
	563	fputs_filtered ("auto", stb);
	564	break;
	565	default:
	566	internal_error (__FILE__, __LINE__,
	567	_("do_show_command: "
	568	"invalid var_auto_boolean"));
	569	break;
899506a8	570	}
5b9afe8a YQ	571	break;
	572	case var_uinteger:
	573	case var_zuinteger:
	574	if (c->var_type == var_uinteger
	575	&& (unsigned int ) c->var == UINT_MAX)
	576	fputs_filtered ("unlimited", stb);
	577	else
	578	fprintf_filtered (stb, "%u", (unsigned int ) c->var);
	579	break;
	580	case var_integer:
	581	case var_zinteger:
	582	if (c->var_type == var_integer
	583	&& (int ) c->var == INT_MAX)
	584	fputs_filtered ("unlimited", stb);
	585	else
	586	fprintf_filtered (stb, "%d", (int ) c->var);
	587	break;
6fc1c773 YQ	588	case var_zuinteger_unlimited:
	589	{
	590	if ((int ) c->var == -1)
	591	fputs_filtered ("unlimited", stb);
	592	else
ef0026f0	593	fprintf_filtered (stb, "%d", (int ) c->var);
6fc1c773 YQ	594	}
6fc1c773 YQ	595	break;
5b9afe8a YQ	596	default:
5b9afe8a YQ	597	error (_("gdb internal error: bad var_type in do_show_command"));
d318976c	598	}
5b9afe8a YQ	599
	600
	601	/* FIXME: cagney/2005-02-10: Need to split this in half: code to
	602	convert the value into a string (esentially the above); and
	603	code to print the value out. For the latter there should be
	604	MI and CLI specific versions. */
	605
	606	if (ui_out_is_mi_like_p (uiout))
	607	ui_out_field_stream (uiout, "value", stb);
d318976c	608	else
5b9afe8a YQ	609	{
	610	char *value = ui_file_xstrdup (stb, NULL);
	611
	612	make_cleanup (xfree, value);
	613	if (c->show_value_func != NULL)
	614	c->show_value_func (gdb_stdout, from_tty, c, value);
	615	else
	616	deprecated_show_value_hack (gdb_stdout, from_tty, c, value);
	617	}
	618	do_cleanups (old_chain);
	619
9f60d481	620	c->func (c, NULL, from_tty);
d318976c FN	621	}
	622
	623	/* Show all the settings in a list of show commands. */
	624
	625	void
	626	cmd_show_list (struct cmd_list_element list, int from_tty, char prefix)
	627	{
3b31d625	628	struct cleanup *showlist_chain;
79a45e25	629	struct ui_out *uiout = current_uiout;
3b31d625 EZ	630
3b31d625 EZ	631	showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
d318976c FN	632	for (; list != NULL; list = list->next)
	633	{
	634	/* If we find a prefix, run its list, prefixing our output by its
	635	prefix (with "show " skipped). */
d318976c FN	636	if (list->prefixlist && !list->abbrev_flag)
d318976c FN	637	{
3b31d625 EZ	638	struct cleanup *optionlist_chain
3b31d625 EZ	639	= make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist");
37fc812e	640	char *new_prefix = strstr (list->prefixname, "show ") + 5;
cdb27c12	641
37fc812e DJ	642	if (ui_out_is_mi_like_p (uiout))
	643	ui_out_field_string (uiout, "prefix", new_prefix);
	644	cmd_show_list (*list->prefixlist, from_tty, new_prefix);
3b31d625 EZ	645	/* Close the tuple. */
3b31d625 EZ	646	do_cleanups (optionlist_chain);
d318976c	647	}
427c3a89	648	else
d318976c	649	{
db5f229b MS	650	if (list->class != no_set_class)
	651	{
	652	struct cleanup *option_chain
	653	= make_cleanup_ui_out_tuple_begin_end (uiout, "option");
	654
	655	ui_out_text (uiout, prefix);
	656	ui_out_field_string (uiout, "name", list->name);
	657	ui_out_text (uiout, ": ");
	658	if (list->type == show_cmd)
5b9afe8a	659	do_show_command ((char *) NULL, from_tty, list);
db5f229b MS	660	else
	661	cmd_func (list, NULL, from_tty);
	662	/* Close the tuple. */
	663	do_cleanups (option_chain);
	664	}
d318976c	665	}
d318976c	666	}
3b31d625 EZ	667	/* Close the tuple. */
3b31d625 EZ	668	do_cleanups (showlist_chain);
d318976c FN	669	}
d318976c FN	670