[thirdparty/binutils-gdb.git] / gdb / mi / mi-cmd-var.c

/* MI Command Set - varobj commands.

   Copyright (C) 2000, 2002, 2004, 2005, 2007 Free Software Foundation, Inc.

   Contributed by Cygnus Solutions (a Red Hat company).

   This file is part of GDB.

   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 "mi-cmds.h"
#include "ui-out.h"
#include "mi-out.h"
#include "varobj.h"
#include "value.h"
#include <ctype.h>
#include "gdb_string.h"

const char mi_no_values[] = "--no-values";
const char mi_simple_values[] = "--simple-values";
const char mi_all_values[] = "--all-values";

extern int varobjdebug;		/* defined in varobj.c.  */

static void varobj_update_one (struct varobj *var,
			      enum print_values print_values,
			      int explicit);

static int mi_print_value_p (struct type *type, enum print_values print_values);

/* Print variable object VAR.  The PRINT_VALUES parameter controls
   if the value should be printed.  The PRINT_EXPRESSION parameter
   controls if the expression should be printed.  */
static void 
print_varobj (struct varobj *var, enum print_values print_values,
	      int print_expression)
{
  char *type;

  ui_out_field_string (uiout, "name", varobj_get_objname (var));
  if (print_expression)
    ui_out_field_string (uiout, "exp", varobj_get_expression (var));
  ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));
  
  if (mi_print_value_p (varobj_get_gdb_type (var), print_values))
    ui_out_field_string (uiout, "value", varobj_get_value (var));

  type = varobj_get_type (var);
  if (type != NULL)
    {
      ui_out_field_string (uiout, "type", type);
      xfree (type);
    }

  if (varobj_get_frozen (var))
    ui_out_field_int (uiout, "frozen", 1);
}

/* VAROBJ operations */

enum mi_cmd_result
mi_cmd_var_create (char *command, char **argv, int argc)
{
  CORE_ADDR frameaddr = 0;
  struct varobj *var;
  char *name;
  char *frame;
  char *expr;
  struct cleanup *old_cleanups;
  enum varobj_type var_type;

  if (argc != 3)
    {
      /* mi_error_message = xstrprintf ("mi_cmd_var_create: Usage:
         ...."); return MI_CMD_ERROR; */
      error (_("mi_cmd_var_create: Usage: NAME FRAME EXPRESSION."));
    }

  name = xstrdup (argv[0]);
  /* Add cleanup for name. Must be free_current_contents as
     name can be reallocated */
  old_cleanups = make_cleanup (free_current_contents, &name);

  frame = xstrdup (argv[1]);
  make_cleanup (xfree, frame);

  expr = xstrdup (argv[2]);
  make_cleanup (xfree, expr);

  if (strcmp (name, "-") == 0)
    {
      xfree (name);
      name = varobj_gen_name ();
    }
  else if (!isalpha (*name))
    error (_("mi_cmd_var_create: name of object must begin with a letter"));

  if (strcmp (frame, "*") == 0)
    var_type = USE_CURRENT_FRAME;
  else if (strcmp (frame, "@") == 0)
    var_type = USE_SELECTED_FRAME;  
  else
    {
      var_type = USE_SPECIFIED_FRAME;
      frameaddr = string_to_core_addr (frame);
    }

  if (varobjdebug)
    fprintf_unfiltered (gdb_stdlog,
		    "Name=\"%s\", Frame=\"%s\" (0x%s), Expression=\"%s\"\n",
			name, frame, paddr (frameaddr), expr);

  var = varobj_create (name, expr, frameaddr, var_type);

  if (var == NULL)
    error (_("mi_cmd_var_create: unable to create variable object"));

  print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */);

  do_cleanups (old_cleanups);
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_delete (char *command, char **argv, int argc)
{
  char *name;
  struct varobj *var;
  int numdel;
  int children_only_p = 0;
  struct cleanup *old_cleanups;

  if (argc < 1 || argc > 2)
    error (_("mi_cmd_var_delete: Usage: [-c] EXPRESSION."));

  name = xstrdup (argv[0]);
  /* Add cleanup for name. Must be free_current_contents as
     name can be reallocated */
  old_cleanups = make_cleanup (free_current_contents, &name);

  /* If we have one single argument it cannot be '-c' or any string
     starting with '-'. */
  if (argc == 1)
    {
      if (strcmp (name, "-c") == 0)
	error (_("mi_cmd_var_delete: Missing required argument after '-c': variable object name"));
      if (*name == '-')
	error (_("mi_cmd_var_delete: Illegal variable object name"));
    }

  /* If we have 2 arguments they must be '-c' followed by a string
     which would be the variable name. */
  if (argc == 2)
    {
      if (strcmp (name, "-c") != 0)
	error (_("mi_cmd_var_delete: Invalid option."));
      children_only_p = 1;
      do_cleanups (old_cleanups);
      name = xstrdup (argv[1]);
      make_cleanup (free_current_contents, &name);
    }

  /* If we didn't error out, now NAME contains the name of the
     variable. */

  var = varobj_get_handle (name);

  if (var == NULL)
    error (_("mi_cmd_var_delete: Variable object not found."));

  numdel = varobj_delete (var, NULL, children_only_p);

  ui_out_field_int (uiout, "ndeleted", numdel);

  do_cleanups (old_cleanups);
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_set_format (char *command, char **argv, int argc)
{
  enum varobj_display_formats format;
  int len;
  struct varobj *var;
  char *formspec;

  if (argc != 2)
    error (_("mi_cmd_var_set_format: Usage: NAME FORMAT."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);

  if (var == NULL)
    error (_("mi_cmd_var_set_format: Variable object not found"));

  formspec = argv[1];
  if (formspec == NULL)
    error (_("mi_cmd_var_set_format: Must specify the format as: \"natural\", \"binary\", \"decimal\", \"hexadecimal\", or \"octal\""));

  len = strlen (formspec);

  if (strncmp (formspec, "natural", len) == 0)
    format = FORMAT_NATURAL;
  else if (strncmp (formspec, "binary", len) == 0)
    format = FORMAT_BINARY;
  else if (strncmp (formspec, "decimal", len) == 0)
    format = FORMAT_DECIMAL;
  else if (strncmp (formspec, "hexadecimal", len) == 0)
    format = FORMAT_HEXADECIMAL;
  else if (strncmp (formspec, "octal", len) == 0)
    format = FORMAT_OCTAL;
  else
    error (_("mi_cmd_var_set_format: Unknown display format: must be: \"natural\", \"binary\", \"decimal\", \"hexadecimal\", or \"octal\""));

  /* Set the format of VAR to given format */
  varobj_set_display_format (var, format);

  /* Report the new current format */
  ui_out_field_string (uiout, "format", varobj_format_string[(int) format]);
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_set_frozen (char *command, char **argv, int argc)
{
  struct varobj *var;
  int frozen;

  if (argc != 2)
    error (_("-var-set-format: Usage: NAME FROZEN_FLAG."));

  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("Variable object not found"));

  if (strcmp (argv[1], "0") == 0)
    frozen = 0;
  else if (strcmp (argv[1], "1") == 0)
    frozen = 1;
  else
    error (_("Invalid flag value"));

  varobj_set_frozen (var, frozen);

  /* We don't automatically return the new value, or what varobjs got new
     values during unfreezing.  If this information is required, client
     should call -var-update explicitly.  */
  return MI_CMD_DONE;
}


enum mi_cmd_result
mi_cmd_var_show_format (char *command, char **argv, int argc)
{
  enum varobj_display_formats format;
  struct varobj *var;

  if (argc != 1)
    error (_("mi_cmd_var_show_format: Usage: NAME."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_show_format: Variable object not found"));

  format = varobj_get_display_format (var);

  /* Report the current format */
  ui_out_field_string (uiout, "format", varobj_format_string[(int) format]);
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_info_num_children (char *command, char **argv, int argc)
{
  struct varobj *var;

  if (argc != 1)
    error (_("mi_cmd_var_info_num_children: Usage: NAME."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_info_num_children: Variable object not found"));

  ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));
  return MI_CMD_DONE;
}

/* Parse a string argument into a print_values value.  */

static enum print_values
mi_parse_values_option (const char *arg)
{
  if (strcmp (arg, "0") == 0
      || strcmp (arg, mi_no_values) == 0)
    return PRINT_NO_VALUES;
  else if (strcmp (arg, "1") == 0
	   || strcmp (arg, mi_all_values) == 0)
    return PRINT_ALL_VALUES;
  else if (strcmp (arg, "2") == 0
	   || strcmp (arg, mi_simple_values) == 0)
    return PRINT_SIMPLE_VALUES;
  else
    error (_("Unknown value for PRINT_VALUES\n\
Must be: 0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
	   mi_no_values, mi_simple_values, mi_all_values);
}

/* Return 1 if given the argument PRINT_VALUES we should display
   a value of type TYPE.  */

static int
mi_print_value_p (struct type *type, enum print_values print_values)
{
  if (type != NULL)
    type = check_typedef (type);

  if (print_values == PRINT_NO_VALUES)
    return 0;

  if (print_values == PRINT_ALL_VALUES)
    return 1;

  /* For PRINT_SIMPLE_VALUES, only print the value if it has a type
     and that type is not a compound type.  */

  return (TYPE_CODE (type) != TYPE_CODE_ARRAY
	  && TYPE_CODE (type) != TYPE_CODE_STRUCT
	  && TYPE_CODE (type) != TYPE_CODE_UNION);
}

enum mi_cmd_result
mi_cmd_var_list_children (char *command, char **argv, int argc)
{
  struct varobj *var;
  struct varobj **childlist;
  struct varobj **cc;
  struct cleanup *cleanup_children;
  int numchild;
  enum print_values print_values;

  if (argc != 1 && argc != 2)
    error (_("mi_cmd_var_list_children: Usage: [PRINT_VALUES] NAME"));

  /* Get varobj handle, if a valid var obj name was specified */
  if (argc == 1)
    var = varobj_get_handle (argv[0]);
  else
    var = varobj_get_handle (argv[1]);
  if (var == NULL)
    error (_("Variable object not found"));

  numchild = varobj_list_children (var, &childlist);
  ui_out_field_int (uiout, "numchild", numchild);
  if (argc == 2)
    print_values = mi_parse_values_option (argv[0]);
  else
    print_values = PRINT_NO_VALUES;

  if (numchild <= 0)
    {
      xfree (childlist);
      return MI_CMD_DONE;
    }

  if (mi_version (uiout) == 1)
    cleanup_children = make_cleanup_ui_out_tuple_begin_end (uiout, "children");
  else
    cleanup_children = make_cleanup_ui_out_list_begin_end (uiout, "children");
  cc = childlist;
  while (*cc != NULL)
    {
      struct cleanup *cleanup_child;
      cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, "child");
      print_varobj (*cc, print_values, 1 /* print expression */);
      cc++;
      do_cleanups (cleanup_child);
    }
  do_cleanups (cleanup_children);
  xfree (childlist);
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_info_type (char *command, char **argv, int argc)
{
  struct varobj *var;

  if (argc != 1)
    error (_("mi_cmd_var_info_type: Usage: NAME."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_info_type: Variable object not found"));

  ui_out_field_string (uiout, "type", varobj_get_type (var));
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_info_expression (char *command, char **argv, int argc)
{
  enum varobj_languages lang;
  struct varobj *var;

  if (argc != 1)
    error (_("mi_cmd_var_info_expression: Usage: NAME."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_info_expression: Variable object not found"));

  lang = varobj_get_language (var);

  ui_out_field_string (uiout, "lang", varobj_language_string[(int) lang]);
  ui_out_field_string (uiout, "exp", varobj_get_expression (var));
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_show_attributes (char *command, char **argv, int argc)
{
  int attr;
  char *attstr;
  struct varobj *var;

  if (argc != 1)
    error (_("mi_cmd_var_show_attributes: Usage: NAME."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_show_attributes: Variable object not found"));

  attr = varobj_get_attributes (var);
  /* FIXME: define masks for attributes */
  if (attr & 0x00000001)
    attstr = "editable";
  else
    attstr = "noneditable";

  ui_out_field_string (uiout, "attr", attstr);
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_evaluate_expression (char *command, char **argv, int argc)
{
  struct varobj *var;

  if (argc != 1)
    error (_("mi_cmd_var_evaluate_expression: Usage: NAME."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_evaluate_expression: Variable object not found"));

  ui_out_field_string (uiout, "value", varobj_get_value (var));
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_assign (char *command, char **argv, int argc)
{
  struct varobj *var;
  char *expression;

  if (argc != 2)
    error (_("mi_cmd_var_assign: Usage: NAME EXPRESSION."));

  /* Get varobj handle, if a valid var obj name was specified */
  var = varobj_get_handle (argv[0]);
  if (var == NULL)
    error (_("mi_cmd_var_assign: Variable object not found"));

  /* FIXME: define masks for attributes */
  if (!(varobj_get_attributes (var) & 0x00000001))
    error (_("mi_cmd_var_assign: Variable object is not editable"));

  expression = xstrdup (argv[1]);

  if (!varobj_set_value (var, expression))
    error (_("mi_cmd_var_assign: Could not assign expression to variable object"));

  ui_out_field_string (uiout, "value", varobj_get_value (var));
  return MI_CMD_DONE;
}

enum mi_cmd_result
mi_cmd_var_update (char *command, char **argv, int argc)
{
  struct varobj *var;
  struct varobj **rootlist;
  struct varobj **cr;
  struct cleanup *cleanup;
  char *name;
  int nv;
  enum print_values print_values;

  if (argc != 1 && argc != 2)
    error (_("mi_cmd_var_update: Usage: [PRINT_VALUES] NAME."));

  if (argc == 1)
    name = argv[0];
  else
    name = (argv[1]);

  if (argc == 2)
    print_values = mi_parse_values_option (argv[0]);
  else
    print_values = PRINT_NO_VALUES;

  /* Check if the parameter is a "*" which means that we want
     to update all variables */

  if ((*name == '*') && (*(name + 1) == '\0'))
    {
      nv = varobj_list (&rootlist);
      cleanup = make_cleanup (xfree, rootlist);
      if (mi_version (uiout) <= 1)
        make_cleanup_ui_out_tuple_begin_end (uiout, "changelist");
      else
        make_cleanup_ui_out_list_begin_end (uiout, "changelist");
      if (nv <= 0)
	{
	  do_cleanups (cleanup);
	  return MI_CMD_DONE;
	}
      cr = rootlist;
      while (*cr != NULL)
	{
	  varobj_update_one (*cr, print_values, 0 /* implicit */);
	  cr++;
	}
      do_cleanups (cleanup);
    }
  else
    {
      /* Get varobj handle, if a valid var obj name was specified */
      var = varobj_get_handle (name);
      if (var == NULL)
	error (_("mi_cmd_var_update: Variable object not found"));

      if (mi_version (uiout) <= 1)
        cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "changelist");
      else
        cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changelist");
      varobj_update_one (var, print_values, 1 /* explicit */);
      do_cleanups (cleanup);
    }
    return MI_CMD_DONE;
}

/* Helper for mi_cmd_var_update().  */

static void
varobj_update_one (struct varobj *var, enum print_values print_values,
		   int explicit)
{
  struct varobj **changelist;
  struct varobj **cc;
  struct cleanup *cleanup = NULL;
  int nc;

  nc = varobj_update (&var, &changelist, explicit);

  /* nc >= 0  represents the number of changes reported into changelist.
     nc < 0   means that an error occured or the the variable has 
              changed type (TYPE_CHANGED).  */
  
  if (nc == 0)
    return;
  else if (nc < 0)
    {
      if (mi_version (uiout) > 1)
        cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
      ui_out_field_string (uiout, "name", varobj_get_objname(var));

      switch (nc)
      {
        case NOT_IN_SCOPE:
          ui_out_field_string (uiout, "in_scope", "false");
	  break;
        case INVALID:
          ui_out_field_string (uiout, "in_scope", "invalid");
 	  break;
        case TYPE_CHANGED:
	  ui_out_field_string (uiout, "in_scope", "true");
          ui_out_field_string (uiout, "new_type", varobj_get_type(var));
          ui_out_field_int (uiout, "new_num_children", 
			    varobj_get_num_children(var));
	  break;
      }
      if (mi_version (uiout) > 1)
        do_cleanups (cleanup);
    }
  else
    {
      cc = changelist;
      while (*cc != NULL)
	{
	  if (mi_version (uiout) > 1)
	    cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
	  ui_out_field_string (uiout, "name", varobj_get_objname (*cc));
	  if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values))
	    ui_out_field_string (uiout, "value", varobj_get_value (*cc));
	  ui_out_field_string (uiout, "in_scope", "true");
	  ui_out_field_string (uiout, "type_changed", "false");
	  if (mi_version (uiout) > 1)
	    do_cleanups (cleanup);
	  cc++;
	}
      xfree (changelist);
    }
}
Commit	Line	Data
fb40c209	1	/* MI Command Set - varobj commands.
349c5d5f	2
6aba47ca	3	Copyright (C) 2000, 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
349c5d5f	4
ab91fdd5	5	Contributed by Cygnus Solutions (a Red Hat company).
fb40c209 AC	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
1caae165 EZ	21	Foundation, Inc., 51 Franklin Street, Fifth Floor,
1caae165 EZ	22	Boston, MA 02110-1301, USA. */
fb40c209 AC	23
	24	#include "defs.h"
	25	#include "mi-cmds.h"
	26	#include "ui-out.h"
	27	#include "mi-out.h"
	28	#include "varobj.h"
	29	#include "value.h"
	30	#include <ctype.h>
5f8a3188	31	#include "gdb_string.h"
fb40c209	32
1ecb4ee0 DJ	33	const char mi_no_values[] = "--no-values";
	34	const char mi_simple_values[] = "--simple-values";
	35	const char mi_all_values[] = "--all-values";
	36
8756216b	37	extern int varobjdebug; /* defined in varobj.c. */
fb40c209	38
8756216b	39	static void varobj_update_one (struct varobj *var,
25d5ea92 VP	40	enum print_values print_values,
25d5ea92 VP	41	int explicit);
fb40c209	42
a217f3f5 VP	43	static int mi_print_value_p (struct type *type, enum print_values print_values);
	44
	45	/* Print variable object VAR. The PRINT_VALUES parameter controls
	46	if the value should be printed. The PRINT_EXPRESSION parameter
	47	controls if the expression should be printed. */
	48	static void
	49	print_varobj (struct varobj *var, enum print_values print_values,
	50	int print_expression)
	51	{
	52	char *type;
	53
	54	ui_out_field_string (uiout, "name", varobj_get_objname (var));
	55	if (print_expression)
	56	ui_out_field_string (uiout, "exp", varobj_get_expression (var));
	57	ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));
	58
	59	if (mi_print_value_p (varobj_get_gdb_type (var), print_values))
	60	ui_out_field_string (uiout, "value", varobj_get_value (var));
	61
	62	type = varobj_get_type (var);
	63	if (type != NULL)
	64	{
	65	ui_out_field_string (uiout, "type", type);
	66	xfree (type);
	67	}
25d5ea92 VP	68
	69	if (varobj_get_frozen (var))
	70	ui_out_field_int (uiout, "frozen", 1);
a217f3f5 VP	71	}
a217f3f5 VP	72
fb40c209 AC	73	/* VAROBJ operations */
	74
	75	enum mi_cmd_result
	76	mi_cmd_var_create (char command, char *argv, int argc)
	77	{
73a93a32	78	CORE_ADDR frameaddr = 0;
fb40c209 AC	79	struct varobj *var;
	80	char *name;
	81	char *frame;
	82	char *expr;
fb40c209	83	struct cleanup *old_cleanups;
73a93a32	84	enum varobj_type var_type;
fb40c209 AC	85
	86	if (argc != 3)
	87	{
c6902d46 AC	88	/* mi_error_message = xstrprintf ("mi_cmd_var_create: Usage:
c6902d46 AC	89	...."); return MI_CMD_ERROR; */
8a3fe4f8	90	error (_("mi_cmd_var_create: Usage: NAME FRAME EXPRESSION."));
fb40c209 AC	91	}
	92
	93	name = xstrdup (argv[0]);
	94	/* Add cleanup for name. Must be free_current_contents as
	95	name can be reallocated */
47cf603e	96	old_cleanups = make_cleanup (free_current_contents, &name);
fb40c209 AC	97
fb40c209 AC	98	frame = xstrdup (argv[1]);
51b57b6b	99	make_cleanup (xfree, frame);
fb40c209 AC	100
fb40c209 AC	101	expr = xstrdup (argv[2]);
51b57b6b	102	make_cleanup (xfree, expr);
fb40c209 AC	103
	104	if (strcmp (name, "-") == 0)
	105	{
b8c9b27d	106	xfree (name);
fb40c209 AC	107	name = varobj_gen_name ();
	108	}
	109	else if (!isalpha (*name))
8a3fe4f8	110	error (_("mi_cmd_var_create: name of object must begin with a letter"));
fb40c209 AC	111
fb40c209 AC	112	if (strcmp (frame, "*") == 0)
73a93a32 JI	113	var_type = USE_CURRENT_FRAME;
	114	else if (strcmp (frame, "@") == 0)
	115	var_type = USE_SELECTED_FRAME;
fb40c209	116	else
73a93a32 JI	117	{
73a93a32 JI	118	var_type = USE_SPECIFIED_FRAME;
1bd34ded	119	frameaddr = string_to_core_addr (frame);
73a93a32	120	}
fb40c209 AC	121
	122	if (varobjdebug)
	123	fprintf_unfiltered (gdb_stdlog,
	124	"Name=\"%s\", Frame=\"%s\" (0x%s), Expression=\"%s\"\n",
	125	name, frame, paddr (frameaddr), expr);
	126
73a93a32	127	var = varobj_create (name, expr, frameaddr, var_type);
fb40c209 AC	128
fb40c209 AC	129	if (var == NULL)
8a3fe4f8	130	error (_("mi_cmd_var_create: unable to create variable object"));
fb40c209	131
224e4ca7	132	print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */);
fb40c209 AC	133
	134	do_cleanups (old_cleanups);
	135	return MI_CMD_DONE;
	136	}
	137
	138	enum mi_cmd_result
	139	mi_cmd_var_delete (char command, char *argv, int argc)
	140	{
	141	char *name;
fb40c209 AC	142	struct varobj *var;
	143	int numdel;
	144	int children_only_p = 0;
	145	struct cleanup *old_cleanups;
	146
	147	if (argc < 1 \|\| argc > 2)
8a3fe4f8	148	error (_("mi_cmd_var_delete: Usage: [-c] EXPRESSION."));
fb40c209 AC	149
	150	name = xstrdup (argv[0]);
	151	/* Add cleanup for name. Must be free_current_contents as
	152	name can be reallocated */
47cf603e	153	old_cleanups = make_cleanup (free_current_contents, &name);
fb40c209 AC	154
	155	/* If we have one single argument it cannot be '-c' or any string
	156	starting with '-'. */
	157	if (argc == 1)
	158	{
	159	if (strcmp (name, "-c") == 0)
8a3fe4f8	160	error (_("mi_cmd_var_delete: Missing required argument after '-c': variable object name"));
fb40c209	161	if (*name == '-')
8a3fe4f8	162	error (_("mi_cmd_var_delete: Illegal variable object name"));
fb40c209 AC	163	}
	164
	165	/* If we have 2 arguments they must be '-c' followed by a string
	166	which would be the variable name. */
	167	if (argc == 2)
	168	{
fb40c209	169	if (strcmp (name, "-c") != 0)
8a3fe4f8	170	error (_("mi_cmd_var_delete: Invalid option."));
fb40c209	171	children_only_p = 1;
474d0d0c MS	172	do_cleanups (old_cleanups);
	173	name = xstrdup (argv[1]);
	174	make_cleanup (free_current_contents, &name);
fb40c209 AC	175	}
	176
	177	/* If we didn't error out, now NAME contains the name of the
	178	variable. */
	179
	180	var = varobj_get_handle (name);
	181
	182	if (var == NULL)
8a3fe4f8	183	error (_("mi_cmd_var_delete: Variable object not found."));
fb40c209 AC	184
	185	numdel = varobj_delete (var, NULL, children_only_p);
	186
	187	ui_out_field_int (uiout, "ndeleted", numdel);
	188
	189	do_cleanups (old_cleanups);
	190	return MI_CMD_DONE;
	191	}
	192
	193	enum mi_cmd_result
	194	mi_cmd_var_set_format (char command, char *argv, int argc)
	195	{
	196	enum varobj_display_formats format;
	197	int len;
	198	struct varobj *var;
	199	char *formspec;
	200
	201	if (argc != 2)
8a3fe4f8	202	error (_("mi_cmd_var_set_format: Usage: NAME FORMAT."));
fb40c209 AC	203
	204	/* Get varobj handle, if a valid var obj name was specified */
	205	var = varobj_get_handle (argv[0]);
	206
	207	if (var == NULL)
8a3fe4f8	208	error (_("mi_cmd_var_set_format: Variable object not found"));
fb40c209	209
b538c234	210	formspec = argv[1];
fb40c209	211	if (formspec == NULL)
8a3fe4f8	212	error (_("mi_cmd_var_set_format: Must specify the format as: \"natural\", \"binary\", \"decimal\", \"hexadecimal\", or \"octal\""));
fb40c209 AC	213
	214	len = strlen (formspec);
	215
bf896cb0	216	if (strncmp (formspec, "natural", len) == 0)
fb40c209	217	format = FORMAT_NATURAL;
bf896cb0	218	else if (strncmp (formspec, "binary", len) == 0)
fb40c209	219	format = FORMAT_BINARY;
bf896cb0	220	else if (strncmp (formspec, "decimal", len) == 0)
fb40c209	221	format = FORMAT_DECIMAL;
bf896cb0	222	else if (strncmp (formspec, "hexadecimal", len) == 0)
fb40c209	223	format = FORMAT_HEXADECIMAL;
bf896cb0	224	else if (strncmp (formspec, "octal", len) == 0)
fb40c209 AC	225	format = FORMAT_OCTAL;
fb40c209 AC	226	else
8a3fe4f8	227	error (_("mi_cmd_var_set_format: Unknown display format: must be: \"natural\", \"binary\", \"decimal\", \"hexadecimal\", or \"octal\""));
fb40c209 AC	228
	229	/* Set the format of VAR to given format */
	230	varobj_set_display_format (var, format);
	231
	232	/* Report the new current format */
	233	ui_out_field_string (uiout, "format", varobj_format_string[(int) format]);
	234	return MI_CMD_DONE;
	235	}
	236
25d5ea92 VP	237	enum mi_cmd_result
	238	mi_cmd_var_set_frozen (char command, char *argv, int argc)
	239	{
	240	struct varobj *var;
	241	int frozen;
	242
	243	if (argc != 2)
	244	error (_("-var-set-format: Usage: NAME FROZEN_FLAG."));
	245
	246	var = varobj_get_handle (argv[0]);
	247	if (var == NULL)
	248	error (_("Variable object not found"));
	249
	250	if (strcmp (argv[1], "0") == 0)
	251	frozen = 0;
	252	else if (strcmp (argv[1], "1") == 0)
	253	frozen = 1;
	254	else
	255	error (_("Invalid flag value"));
	256
	257	varobj_set_frozen (var, frozen);
	258
	259	/* We don't automatically return the new value, or what varobjs got new
	260	values during unfreezing. If this information is required, client
	261	should call -var-update explicitly. */
	262	return MI_CMD_DONE;
	263	}
	264
	265
fb40c209 AC	266	enum mi_cmd_result
	267	mi_cmd_var_show_format (char command, char *argv, int argc)
	268	{
	269	enum varobj_display_formats format;
	270	struct varobj *var;
	271
	272	if (argc != 1)
8a3fe4f8	273	error (_("mi_cmd_var_show_format: Usage: NAME."));
fb40c209 AC	274
	275	/* Get varobj handle, if a valid var obj name was specified */
	276	var = varobj_get_handle (argv[0]);
	277	if (var == NULL)
8a3fe4f8	278	error (_("mi_cmd_var_show_format: Variable object not found"));
fb40c209 AC	279
	280	format = varobj_get_display_format (var);
	281
	282	/* Report the current format */
	283	ui_out_field_string (uiout, "format", varobj_format_string[(int) format]);
	284	return MI_CMD_DONE;
	285	}
	286
	287	enum mi_cmd_result
	288	mi_cmd_var_info_num_children (char command, char *argv, int argc)
	289	{
	290	struct varobj *var;
	291
	292	if (argc != 1)
8a3fe4f8	293	error (_("mi_cmd_var_info_num_children: Usage: NAME."));
fb40c209 AC	294
	295	/* Get varobj handle, if a valid var obj name was specified */
	296	var = varobj_get_handle (argv[0]);
	297	if (var == NULL)
8a3fe4f8	298	error (_("mi_cmd_var_info_num_children: Variable object not found"));
fb40c209 AC	299
	300	ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));
	301	return MI_CMD_DONE;
	302	}
	303
1ecb4ee0 DJ	304	/* Parse a string argument into a print_values value. */
	305
	306	static enum print_values
	307	mi_parse_values_option (const char *arg)
	308	{
	309	if (strcmp (arg, "0") == 0
	310	\|\| strcmp (arg, mi_no_values) == 0)
	311	return PRINT_NO_VALUES;
	312	else if (strcmp (arg, "1") == 0
	313	\|\| strcmp (arg, mi_all_values) == 0)
	314	return PRINT_ALL_VALUES;
	315	else if (strcmp (arg, "2") == 0
	316	\|\| strcmp (arg, mi_simple_values) == 0)
	317	return PRINT_SIMPLE_VALUES;
	318	else
	319	error (_("Unknown value for PRINT_VALUES\n\
	320	Must be: 0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
	321	mi_no_values, mi_simple_values, mi_all_values);
	322	}
	323
	324	/* Return 1 if given the argument PRINT_VALUES we should display
	325	a value of type TYPE. */
	326
	327	static int
	328	mi_print_value_p (struct type *type, enum print_values print_values)
	329	{
	330	if (type != NULL)
	331	type = check_typedef (type);
	332
	333	if (print_values == PRINT_NO_VALUES)
	334	return 0;
	335
	336	if (print_values == PRINT_ALL_VALUES)
	337	return 1;
	338
	339	/* For PRINT_SIMPLE_VALUES, only print the value if it has a type
	340	and that type is not a compound type. */
	341
	342	return (TYPE_CODE (type) != TYPE_CODE_ARRAY
	343	&& TYPE_CODE (type) != TYPE_CODE_STRUCT
	344	&& TYPE_CODE (type) != TYPE_CODE_UNION);
	345	}
	346
fb40c209 AC	347	enum mi_cmd_result
	348	mi_cmd_var_list_children (char command, char *argv, int argc)
	349	{
	350	struct varobj *var;
	351	struct varobj **childlist;
	352	struct varobj **cc;
6ad4a2cf	353	struct cleanup *cleanup_children;
fb40c209	354	int numchild;
c9e1f0fc	355	enum print_values print_values;
fb40c209	356
c9e1f0fc	357	if (argc != 1 && argc != 2)
8a3fe4f8	358	error (_("mi_cmd_var_list_children: Usage: [PRINT_VALUES] NAME"));
fb40c209 AC	359
fb40c209 AC	360	/* Get varobj handle, if a valid var obj name was specified */
1ecb4ee0 DJ	361	if (argc == 1)
	362	var = varobj_get_handle (argv[0]);
	363	else
	364	var = varobj_get_handle (argv[1]);
fb40c209	365	if (var == NULL)
8a3fe4f8	366	error (_("Variable object not found"));
fb40c209 AC	367
	368	numchild = varobj_list_children (var, &childlist);
	369	ui_out_field_int (uiout, "numchild", numchild);
c9e1f0fc	370	if (argc == 2)
1ecb4ee0 DJ	371	print_values = mi_parse_values_option (argv[0]);
	372	else
	373	print_values = PRINT_NO_VALUES;
fb40c209 AC	374
fb40c209 AC	375	if (numchild <= 0)
76bd6e0b MS	376	{
	377	xfree (childlist);
	378	return MI_CMD_DONE;
	379	}
fb40c209	380
e7494ffb AC	381	if (mi_version (uiout) == 1)
	382	cleanup_children = make_cleanup_ui_out_tuple_begin_end (uiout, "children");
	383	else
	384	cleanup_children = make_cleanup_ui_out_list_begin_end (uiout, "children");
fb40c209 AC	385	cc = childlist;
	386	while (*cc != NULL)
	387	{
6ad4a2cf JJ	388	struct cleanup *cleanup_child;
6ad4a2cf JJ	389	cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, "child");
a217f3f5	390	print_varobj (cc, print_values, 1 / print expression */);
fb40c209	391	cc++;
a217f3f5	392	do_cleanups (cleanup_child);
fb40c209	393	}
6ad4a2cf	394	do_cleanups (cleanup_children);
b8c9b27d	395	xfree (childlist);
fb40c209 AC	396	return MI_CMD_DONE;
	397	}
	398
	399	enum mi_cmd_result
	400	mi_cmd_var_info_type (char command, char *argv, int argc)
	401	{
	402	struct varobj *var;
	403
	404	if (argc != 1)
8a3fe4f8	405	error (_("mi_cmd_var_info_type: Usage: NAME."));
fb40c209 AC	406
	407	/* Get varobj handle, if a valid var obj name was specified */
	408	var = varobj_get_handle (argv[0]);
	409	if (var == NULL)
8a3fe4f8	410	error (_("mi_cmd_var_info_type: Variable object not found"));
fb40c209 AC	411
	412	ui_out_field_string (uiout, "type", varobj_get_type (var));
	413	return MI_CMD_DONE;
	414	}
	415
	416	enum mi_cmd_result
	417	mi_cmd_var_info_expression (char command, char *argv, int argc)
	418	{
	419	enum varobj_languages lang;
	420	struct varobj *var;
	421
	422	if (argc != 1)
8a3fe4f8	423	error (_("mi_cmd_var_info_expression: Usage: NAME."));
fb40c209 AC	424
	425	/* Get varobj handle, if a valid var obj name was specified */
	426	var = varobj_get_handle (argv[0]);
	427	if (var == NULL)
8a3fe4f8	428	error (_("mi_cmd_var_info_expression: Variable object not found"));
fb40c209 AC	429
	430	lang = varobj_get_language (var);
	431
	432	ui_out_field_string (uiout, "lang", varobj_language_string[(int) lang]);
	433	ui_out_field_string (uiout, "exp", varobj_get_expression (var));
	434	return MI_CMD_DONE;
	435	}
	436
	437	enum mi_cmd_result
	438	mi_cmd_var_show_attributes (char command, char *argv, int argc)
	439	{
	440	int attr;
	441	char *attstr;
	442	struct varobj *var;
	443
	444	if (argc != 1)
8a3fe4f8	445	error (_("mi_cmd_var_show_attributes: Usage: NAME."));
fb40c209 AC	446
	447	/* Get varobj handle, if a valid var obj name was specified */
	448	var = varobj_get_handle (argv[0]);
	449	if (var == NULL)
8a3fe4f8	450	error (_("mi_cmd_var_show_attributes: Variable object not found"));
fb40c209 AC	451
	452	attr = varobj_get_attributes (var);
	453	/* FIXME: define masks for attributes */
	454	if (attr & 0x00000001)
	455	attstr = "editable";
	456	else
	457	attstr = "noneditable";
	458
	459	ui_out_field_string (uiout, "attr", attstr);
	460	return MI_CMD_DONE;
	461	}
	462
	463	enum mi_cmd_result
	464	mi_cmd_var_evaluate_expression (char command, char *argv, int argc)
	465	{
	466	struct varobj *var;
	467
	468	if (argc != 1)
8a3fe4f8	469	error (_("mi_cmd_var_evaluate_expression: Usage: NAME."));
fb40c209 AC	470
	471	/* Get varobj handle, if a valid var obj name was specified */
	472	var = varobj_get_handle (argv[0]);
	473	if (var == NULL)
8a3fe4f8	474	error (_("mi_cmd_var_evaluate_expression: Variable object not found"));
fb40c209 AC	475
	476	ui_out_field_string (uiout, "value", varobj_get_value (var));
	477	return MI_CMD_DONE;
	478	}
	479
	480	enum mi_cmd_result
	481	mi_cmd_var_assign (char command, char *argv, int argc)
	482	{
	483	struct varobj *var;
	484	char *expression;
	485
	486	if (argc != 2)
8a3fe4f8	487	error (_("mi_cmd_var_assign: Usage: NAME EXPRESSION."));
fb40c209 AC	488
	489	/* Get varobj handle, if a valid var obj name was specified */
	490	var = varobj_get_handle (argv[0]);
	491	if (var == NULL)
8a3fe4f8	492	error (_("mi_cmd_var_assign: Variable object not found"));
fb40c209 AC	493
	494	/* FIXME: define masks for attributes */
	495	if (!(varobj_get_attributes (var) & 0x00000001))
8a3fe4f8	496	error (_("mi_cmd_var_assign: Variable object is not editable"));
fb40c209 AC	497
	498	expression = xstrdup (argv[1]);
	499
	500	if (!varobj_set_value (var, expression))
98a29c7e	501	error (_("mi_cmd_var_assign: Could not assign expression to variable object"));
fb40c209 AC	502
	503	ui_out_field_string (uiout, "value", varobj_get_value (var));
	504	return MI_CMD_DONE;
	505	}
	506
	507	enum mi_cmd_result
	508	mi_cmd_var_update (char command, char *argv, int argc)
	509	{
	510	struct varobj *var;
	511	struct varobj **rootlist;
	512	struct varobj **cr;
3a387118	513	struct cleanup *cleanup;
fb40c209 AC	514	char *name;
fb40c209 AC	515	int nv;
1ecb4ee0	516	enum print_values print_values;
fb40c209	517
1ecb4ee0 DJ	518	if (argc != 1 && argc != 2)
	519	error (_("mi_cmd_var_update: Usage: [PRINT_VALUES] NAME."));
	520
	521	if (argc == 1)
	522	name = argv[0];
	523	else
	524	name = (argv[1]);
fb40c209	525
1ecb4ee0 DJ	526	if (argc == 2)
	527	print_values = mi_parse_values_option (argv[0]);
	528	else
	529	print_values = PRINT_NO_VALUES;
fb40c209 AC	530
	531	/* Check if the parameter is a "*" which means that we want
	532	to update all variables */
	533
	534	if ((name == '') && (*(name + 1) == '\0'))
	535	{
	536	nv = varobj_list (&rootlist);
db9a518b	537	cleanup = make_cleanup (xfree, rootlist);
3a387118	538	if (mi_version (uiout) <= 1)
db9a518b	539	make_cleanup_ui_out_tuple_begin_end (uiout, "changelist");
3a387118	540	else
db9a518b	541	make_cleanup_ui_out_list_begin_end (uiout, "changelist");
fb40c209 AC	542	if (nv <= 0)
fb40c209 AC	543	{
3a387118	544	do_cleanups (cleanup);
fb40c209 AC	545	return MI_CMD_DONE;
	546	}
	547	cr = rootlist;
	548	while (*cr != NULL)
	549	{
25d5ea92	550	varobj_update_one (cr, print_values, 0 / implicit */);
fb40c209 AC	551	cr++;
fb40c209 AC	552	}
3a387118	553	do_cleanups (cleanup);
fb40c209 AC	554	}
	555	else
	556	{
	557	/* Get varobj handle, if a valid var obj name was specified */
	558	var = varobj_get_handle (name);
	559	if (var == NULL)
8a3fe4f8	560	error (_("mi_cmd_var_update: Variable object not found"));
fb40c209	561
3a387118 JJ	562	if (mi_version (uiout) <= 1)
	563	cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "changelist");
	564	else
	565	cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changelist");
25d5ea92	566	varobj_update_one (var, print_values, 1 /* explicit */);
3a387118	567	do_cleanups (cleanup);
fb40c209	568	}
73a93a32	569	return MI_CMD_DONE;
fb40c209 AC	570	}
fb40c209 AC	571
8756216b	572	/* Helper for mi_cmd_var_update(). */
fb40c209	573
8756216b	574	static void
25d5ea92 VP	575	varobj_update_one (struct varobj *var, enum print_values print_values,
25d5ea92 VP	576	int explicit)
fb40c209 AC	577	{
	578	struct varobj **changelist;
	579	struct varobj **cc;
3a387118	580	struct cleanup *cleanup = NULL;
fb40c209 AC	581	int nc;
fb40c209 AC	582
25d5ea92	583	nc = varobj_update (&var, &changelist, explicit);
fb40c209	584
8756216b DP	585	/* nc >= 0 represents the number of changes reported into changelist.
	586	nc < 0 means that an error occured or the the variable has
	587	changed type (TYPE_CHANGED). */
73a93a32 JI	588
73a93a32 JI	589	if (nc == 0)
8756216b DP	590	return;
8756216b DP	591	else if (nc < 0)
fb40c209	592	{
3a387118 JJ	593	if (mi_version (uiout) > 1)
3a387118 JJ	594	cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
73a93a32	595	ui_out_field_string (uiout, "name", varobj_get_objname(var));
8756216b DP	596
	597	switch (nc)
	598	{
	599	case NOT_IN_SCOPE:
8756216b DP	600	ui_out_field_string (uiout, "in_scope", "false");
	601	break;
	602	case INVALID:
	603	ui_out_field_string (uiout, "in_scope", "invalid");
	604	break;
	605	case TYPE_CHANGED:
	606	ui_out_field_string (uiout, "in_scope", "true");
	607	ui_out_field_string (uiout, "new_type", varobj_get_type(var));
	608	ui_out_field_int (uiout, "new_num_children",
	609	varobj_get_num_children(var));
	610	break;
	611	}
3a387118 JJ	612	if (mi_version (uiout) > 1)
3a387118 JJ	613	do_cleanups (cleanup);
73a93a32 JI	614	}
	615	else
	616	{
73a93a32 JI	617	cc = changelist;
	618	while (*cc != NULL)
	619	{
3a387118 JJ	620	if (mi_version (uiout) > 1)
3a387118 JJ	621	cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
73a93a32	622	ui_out_field_string (uiout, "name", varobj_get_objname (*cc));
1ecb4ee0 DJ	623	if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values))
1ecb4ee0 DJ	624	ui_out_field_string (uiout, "value", varobj_get_value (*cc));
73a93a32 JI	625	ui_out_field_string (uiout, "in_scope", "true");
73a93a32 JI	626	ui_out_field_string (uiout, "type_changed", "false");
3a387118 JJ	627	if (mi_version (uiout) > 1)
3a387118 JJ	628	do_cleanups (cleanup);
73a93a32 JI	629	cc++;
73a93a32 JI	630	}
b8c9b27d	631	xfree (changelist);
fb40c209	632	}
fb40c209	633	}