[deliverable/binutils-gdb.git] / gdb / mi / mi-cmd-stack.c

/* MI Command Set - stack commands.
   Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
   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 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 "target.h"
#include "frame.h"
#include "value.h"
#include "mi-cmds.h"
#include "ui-out.h"
#include "symtab.h"
#include "block.h"
#include "stack.h"
#include "dictionary.h"
#include "gdb_string.h"
#include "language.h"
#include "valprint.h"
#include "exceptions.h"

enum what_to_list { locals, arguments, all };

static void list_args_or_locals (enum what_to_list what, 
				 int values, struct frame_info *fi);

/* Print a list of the stack frames. Args can be none, in which case
   we want to print the whole backtrace, or a pair of numbers
   specifying the frame numbers at which to start and stop the
   display. If the two numbers are equal, a single frame will be
   displayed. */
void
mi_cmd_stack_list_frames (char *command, char **argv, int argc)
{
  int frame_low;
  int frame_high;
  int i;
  struct cleanup *cleanup_stack;
  struct frame_info *fi;

  if (argc > 2 || argc == 1)
    error (_("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]"));

  if (argc == 2)
    {
      frame_low = atoi (argv[0]);
      frame_high = atoi (argv[1]);
    }
  else
    {
      /* Called with no arguments, it means we want the whole
         backtrace. */
      frame_low = -1;
      frame_high = -1;
    }

  /* Let's position fi on the frame at which to start the
     display. Could be the innermost frame if the whole stack needs
     displaying, or if frame_low is 0. */
  for (i = 0, fi = get_current_frame ();
       fi && i < frame_low;
       i++, fi = get_prev_frame (fi));

  if (fi == NULL)
    error (_("mi_cmd_stack_list_frames: Not enough frames in stack."));

  cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "stack");

  /* Now let;s print the frames up to frame_high, or until there are
     frames in the stack. */
  for (;
       fi && (i <= frame_high || frame_high == -1);
       i++, fi = get_prev_frame (fi))
    {
      QUIT;
      /* Print the location and the address always, even for level 0.
         args == 0: don't print the arguments. */
      print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
    }

  do_cleanups (cleanup_stack);
}

void
mi_cmd_stack_info_depth (char *command, char **argv, int argc)
{
  int frame_high;
  int i;
  struct frame_info *fi;

  if (argc > 1)
    error (_("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"));

  if (argc == 1)
    frame_high = atoi (argv[0]);
  else
    /* Called with no arguments, it means we want the real depth of
       the stack. */
    frame_high = -1;

  for (i = 0, fi = get_current_frame ();
       fi && (i < frame_high || frame_high == -1);
       i++, fi = get_prev_frame (fi))
    QUIT;

  ui_out_field_int (uiout, "depth", i);
}

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

/* Print a list of the locals for the current frame.  With argument of
   0, print only the names, with argument of 1 print also the
   values. */
void
mi_cmd_stack_list_locals (char *command, char **argv, int argc)
{
  struct frame_info *frame;

  if (argc != 1)
    error (_("mi_cmd_stack_list_locals: Usage: PRINT_VALUES"));

   frame = get_selected_frame (NULL);

   list_args_or_locals (locals, parse_print_values (argv[0]), frame);
}

/* Print a list of the arguments for the current frame.  With argument
   of 0, print only the names, with argument of 1 print also the
   values. */
void
mi_cmd_stack_list_args (char *command, char **argv, int argc)
{
  int frame_low;
  int frame_high;
  int i;
  struct frame_info *fi;
  struct cleanup *cleanup_stack_args;
  enum print_values print_values;

  if (argc < 1 || argc > 3 || argc == 2)
    error (_("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));

  if (argc == 3)
    {
      frame_low = atoi (argv[1]);
      frame_high = atoi (argv[2]);
    }
  else
    {
      /* Called with no arguments, it means we want args for the whole
         backtrace. */
      frame_low = -1;
      frame_high = -1;
    }

  print_values = parse_print_values (argv[0]);

  /* Let's position fi on the frame at which to start the
     display. Could be the innermost frame if the whole stack needs
     displaying, or if frame_low is 0. */
  for (i = 0, fi = get_current_frame ();
       fi && i < frame_low;
       i++, fi = get_prev_frame (fi));

  if (fi == NULL)
    error (_("mi_cmd_stack_list_args: Not enough frames in stack."));

  cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");

  /* Now let's print the frames up to frame_high, or until there are
     frames in the stack. */
  for (;
       fi && (i <= frame_high || frame_high == -1);
       i++, fi = get_prev_frame (fi))
    {
      struct cleanup *cleanup_frame;

      QUIT;
      cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
      ui_out_field_int (uiout, "level", i);
      list_args_or_locals (arguments, print_values, fi);
      do_cleanups (cleanup_frame);
    }

  do_cleanups (cleanup_stack_args);
}

/* Print a list of the local variables (including arguments) for the 
   current frame.  ARGC must be 1 and ARGV[0] specify if only the names,
   or both names and values of the variables must be printed.  See 
   parse_print_value for possible values.  */
void
mi_cmd_stack_list_variables (char *command, char **argv, int argc)
{
  struct frame_info *frame;

  if (argc != 1)
    error (_("Usage: PRINT_VALUES"));

  frame = get_selected_frame (NULL);

  list_args_or_locals (all, parse_print_values (argv[0]), frame);
}


/* Print a list of the locals or the arguments for the currently
   selected frame.  If the argument passed is 0, printonly the names
   of the variables, if an argument of 1 is passed, print the values
   as well. */
static void
list_args_or_locals (enum what_to_list what, int values, struct frame_info *fi)
{
  struct block *block;
  struct symbol *sym;
  struct dict_iterator iter;
  struct cleanup *cleanup_list;
  static struct ui_stream *stb = NULL;
  struct type *type;
  char *name_of_result;

  stb = ui_out_stream_new (uiout);

  block = get_frame_block (fi, 0);

  switch (what)
    {
    case locals:
      name_of_result = "locals";
      break;
    case arguments:
      name_of_result = "args";
      break;
    case all:
      name_of_result = "variables";
      break;
    default:
      internal_error (__FILE__, __LINE__,
		      "unexpected what_to_list: %d", (int) what);
    }

  cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);

  while (block != 0)
    {
      ALL_BLOCK_SYMBOLS (block, iter, sym)
	{
          int print_me = 0;

	  switch (SYMBOL_CLASS (sym))
	    {
	    default:
	    case LOC_UNDEF:	/* catches errors        */
	    case LOC_CONST:	/* constant              */
	    case LOC_TYPEDEF:	/* local typedef         */
	    case LOC_LABEL:	/* local label           */
	    case LOC_BLOCK:	/* local function        */
	    case LOC_CONST_BYTES:	/* loc. byte seq.        */
	    case LOC_UNRESOLVED:	/* unresolved static     */
	    case LOC_OPTIMIZED_OUT:	/* optimized out         */
	      print_me = 0;
	      break;

	    case LOC_ARG:	/* argument              */
	    case LOC_REF_ARG:	/* reference arg         */
	    case LOC_REGPARM_ADDR:	/* indirect register arg */
	    case LOC_LOCAL:	/* stack local           */
	    case LOC_STATIC:	/* static                */
	    case LOC_REGISTER:	/* register              */
	    case LOC_COMPUTED:	/* computed location     */
	      if (what == all)
		print_me = 1;
	      else if (what == locals)
		print_me = !SYMBOL_IS_ARGUMENT (sym);
	      else
		print_me = SYMBOL_IS_ARGUMENT (sym);
	      break;
	    }
	  if (print_me)
	    {
	      struct cleanup *cleanup_tuple = NULL;
	      struct symbol *sym2;
	      struct value *val;

	      if (values != PRINT_NO_VALUES || what == all)
		cleanup_tuple =
		  make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
	      ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
	      if (what == all && SYMBOL_IS_ARGUMENT (sym))
		ui_out_field_int (uiout, "arg", 1);

	      if (SYMBOL_IS_ARGUMENT (sym))
		sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
				      block, VAR_DOMAIN,
				      (int *) NULL);
	      else
		sym2 = sym;
	      switch (values)
		{
		case PRINT_SIMPLE_VALUES:
		  type = check_typedef (sym2->type);
		  type_print (sym2->type, "", stb->stream, -1);
		  ui_out_field_stream (uiout, "type", stb);
		  if (TYPE_CODE (type) != TYPE_CODE_ARRAY
		      && TYPE_CODE (type) != TYPE_CODE_STRUCT
		      && TYPE_CODE (type) != TYPE_CODE_UNION)
		    {
		      volatile struct gdb_exception except;

		      TRY_CATCH (except, RETURN_MASK_ERROR)
			{
			  struct value_print_options opts;

			  val = read_var_value (sym2, fi);
			  get_raw_print_options (&opts);
			  opts.deref_ref = 1;
			  common_val_print
			    (val, stb->stream, 0, &opts,
			     language_def (SYMBOL_LANGUAGE (sym2)));
			}
		      if (except.reason < 0)
			fprintf_filtered (stb->stream,
					  _("<error reading variable: %s>"),
					  except.message);

		      ui_out_field_stream (uiout, "value", stb);
		    }
		  break;
		case PRINT_ALL_VALUES:
		  {
		    volatile struct gdb_exception except;

		    TRY_CATCH (except, RETURN_MASK_ERROR)
		      {
			struct value_print_options opts;

			val = read_var_value (sym2, fi);
			get_raw_print_options (&opts);
			opts.deref_ref = 1;
			common_val_print
			  (val, stb->stream, 0, &opts,
			   language_def (SYMBOL_LANGUAGE (sym2)));
		      }
		    if (except.reason < 0)
		      fprintf_filtered (stb->stream,
					_("<error reading variable: %s>"),
					except.message);

		    ui_out_field_stream (uiout, "value", stb);
		  }
		  break;
		}

	      if (values != PRINT_NO_VALUES || what == all)
		do_cleanups (cleanup_tuple);
	    }
	}
      if (BLOCK_FUNCTION (block))
	break;
      else
	block = BLOCK_SUPERBLOCK (block);
    }
  do_cleanups (cleanup_list);
  ui_out_stream_delete (stb);
}

void
mi_cmd_stack_select_frame (char *command, char **argv, int argc)
{
  if (argc == 0 || argc > 1)
    error (_("mi_cmd_stack_select_frame: Usage: FRAME_SPEC"));

  select_frame_command (argv[0], 1 /* not used */ );
}

void
mi_cmd_stack_info_frame (char *command, char **argv, int argc)
{
  if (argc > 0)
    error (_("mi_cmd_stack_info_frame: No arguments required"));

  print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
}
Commit	Line	Data
fb40c209	1	/* MI Command Set - stack commands.
7b6bb8da	2	Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
6aba47ca	3	Free Software Foundation, Inc.
ab91fdd5	4	Contributed by Cygnus Solutions (a Red Hat company).
fb40c209 AC	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
fb40c209 AC	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
fb40c209 AC	20
	21	#include "defs.h"
	22	#include "target.h"
	23	#include "frame.h"
	24	#include "value.h"
	25	#include "mi-cmds.h"
	26	#include "ui-out.h"
e88c90f2	27	#include "symtab.h"
fe898f56	28	#include "block.h"
b9362cc7	29	#include "stack.h"
de4f826b	30	#include "dictionary.h"
f5ec2042	31	#include "gdb_string.h"
d8ca156b	32	#include "language.h"
79a45b7d	33	#include "valprint.h"
875b4ff5	34	#include "exceptions.h"
daf3c977 VP	35
	36	enum what_to_list { locals, arguments, all };
	37
	38	static void list_args_or_locals (enum what_to_list what,
	39	int values, struct frame_info *fi);
fb40c209 AC	40
	41	/* Print a list of the stack frames. Args can be none, in which case
	42	we want to print the whole backtrace, or a pair of numbers
	43	specifying the frame numbers at which to start and stop the
	44	display. If the two numbers are equal, a single frame will be
	45	displayed. */
ce8f13f8	46	void
fb40c209 AC	47	mi_cmd_stack_list_frames (char command, char *argv, int argc)
	48	{
	49	int frame_low;
	50	int frame_high;
	51	int i;
6ad4a2cf	52	struct cleanup *cleanup_stack;
fb40c209 AC	53	struct frame_info *fi;
fb40c209 AC	54
fb40c209	55	if (argc > 2 \|\| argc == 1)
8a3fe4f8	56	error (_("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]"));
fb40c209 AC	57
	58	if (argc == 2)
	59	{
	60	frame_low = atoi (argv[0]);
	61	frame_high = atoi (argv[1]);
	62	}
	63	else
	64	{
	65	/* Called with no arguments, it means we want the whole
	66	backtrace. */
	67	frame_low = -1;
	68	frame_high = -1;
	69	}
	70
	71	/* Let's position fi on the frame at which to start the
	72	display. Could be the innermost frame if the whole stack needs
	73	displaying, or if frame_low is 0. */
	74	for (i = 0, fi = get_current_frame ();
	75	fi && i < frame_low;
	76	i++, fi = get_prev_frame (fi));
	77
	78	if (fi == NULL)
8a3fe4f8	79	error (_("mi_cmd_stack_list_frames: Not enough frames in stack."));
fb40c209	80
6ad4a2cf	81	cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "stack");
fb40c209 AC	82
	83	/* Now let;s print the frames up to frame_high, or until there are
	84	frames in the stack. */
	85	for (;
	86	fi && (i <= frame_high \|\| frame_high == -1);
	87	i++, fi = get_prev_frame (fi))
	88	{
	89	QUIT;
0faf0076	90	/* Print the location and the address always, even for level 0.
fb40c209	91	args == 0: don't print the arguments. */
0faf0076	92	print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
fb40c209 AC	93	}
fb40c209 AC	94
6ad4a2cf	95	do_cleanups (cleanup_stack);
fb40c209 AC	96	}
fb40c209 AC	97
ce8f13f8	98	void
fb40c209 AC	99	mi_cmd_stack_info_depth (char command, char *argv, int argc)
	100	{
	101	int frame_high;
	102	int i;
	103	struct frame_info *fi;
	104
fb40c209	105	if (argc > 1)
8a3fe4f8	106	error (_("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"));
fb40c209 AC	107
	108	if (argc == 1)
	109	frame_high = atoi (argv[0]);
	110	else
	111	/* Called with no arguments, it means we want the real depth of
	112	the stack. */
	113	frame_high = -1;
	114
	115	for (i = 0, fi = get_current_frame ();
	116	fi && (i < frame_high \|\| frame_high == -1);
	117	i++, fi = get_prev_frame (fi))
	118	QUIT;
	119
	120	ui_out_field_int (uiout, "depth", i);
fb40c209 AC	121	}
fb40c209 AC	122
8b777f02 VP	123	static enum print_values
	124	parse_print_values (char *name)
	125	{
	126	if (strcmp (name, "0") == 0
	127	\|\| strcmp (name, mi_no_values) == 0)
	128	return PRINT_NO_VALUES;
	129	else if (strcmp (name, "1") == 0
	130	\|\| strcmp (name, mi_all_values) == 0)
	131	return PRINT_ALL_VALUES;
	132	else if (strcmp (name, "2") == 0
	133	\|\| strcmp (name, mi_simple_values) == 0)
	134	return PRINT_SIMPLE_VALUES;
	135	else
	136	error (_("Unknown value for PRINT_VALUES: must be: \
	137	0 or \"%s\", 1 or \"%s\", 2 or \"%s\""),
	138	mi_no_values, mi_all_values, mi_simple_values);
	139	}
	140
7a93fb82	141	/* Print a list of the locals for the current frame. With argument of
fb40c209 AC	142	0, print only the names, with argument of 1 print also the
fb40c209 AC	143	values. */
ce8f13f8	144	void
fb40c209 AC	145	mi_cmd_stack_list_locals (char command, char *argv, int argc)
fb40c209 AC	146	{
f5ec2042	147	struct frame_info *frame;
f5ec2042	148
fb40c209	149	if (argc != 1)
8a3fe4f8	150	error (_("mi_cmd_stack_list_locals: Usage: PRINT_VALUES"));
fb40c209	151
b04f3ab4	152	frame = get_selected_frame (NULL);
f5ec2042	153
daf3c977	154	list_args_or_locals (locals, parse_print_values (argv[0]), frame);
fb40c209 AC	155	}
fb40c209 AC	156
7a93fb82	157	/* Print a list of the arguments for the current frame. With argument
fb40c209 AC	158	of 0, print only the names, with argument of 1 print also the
fb40c209 AC	159	values. */
ce8f13f8	160	void
fb40c209 AC	161	mi_cmd_stack_list_args (char command, char *argv, int argc)
	162	{
	163	int frame_low;
	164	int frame_high;
	165	int i;
	166	struct frame_info *fi;
6ad4a2cf	167	struct cleanup *cleanup_stack_args;
8b777f02	168	enum print_values print_values;
fb40c209 AC	169
fb40c209 AC	170	if (argc < 1 \|\| argc > 3 \|\| argc == 2)
8a3fe4f8	171	error (_("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
fb40c209 AC	172
	173	if (argc == 3)
	174	{
	175	frame_low = atoi (argv[1]);
	176	frame_high = atoi (argv[2]);
	177	}
	178	else
	179	{
	180	/* Called with no arguments, it means we want args for the whole
	181	backtrace. */
	182	frame_low = -1;
	183	frame_high = -1;
	184	}
	185
8b777f02 VP	186	print_values = parse_print_values (argv[0]);
8b777f02 VP	187
fb40c209 AC	188	/* Let's position fi on the frame at which to start the
	189	display. Could be the innermost frame if the whole stack needs
	190	displaying, or if frame_low is 0. */
	191	for (i = 0, fi = get_current_frame ();
	192	fi && i < frame_low;
	193	i++, fi = get_prev_frame (fi));
	194
	195	if (fi == NULL)
8a3fe4f8	196	error (_("mi_cmd_stack_list_args: Not enough frames in stack."));
fb40c209	197
6ad4a2cf	198	cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
fb40c209 AC	199
	200	/* Now let's print the frames up to frame_high, or until there are
	201	frames in the stack. */
	202	for (;
	203	fi && (i <= frame_high \|\| frame_high == -1);
	204	i++, fi = get_prev_frame (fi))
	205	{
6ad4a2cf	206	struct cleanup *cleanup_frame;
102040f0	207
fb40c209	208	QUIT;
6ad4a2cf	209	cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
fb40c209	210	ui_out_field_int (uiout, "level", i);
daf3c977	211	list_args_or_locals (arguments, print_values, fi);
6ad4a2cf	212	do_cleanups (cleanup_frame);
fb40c209 AC	213	}
fb40c209 AC	214
6ad4a2cf	215	do_cleanups (cleanup_stack_args);
fb40c209 AC	216	}
fb40c209 AC	217
daf3c977	218	/* Print a list of the local variables (including arguments) for the
7a93fb82 VP	219	current frame. ARGC must be 1 and ARGV[0] specify if only the names,
	220	or both names and values of the variables must be printed. See
	221	parse_print_value for possible values. */
daf3c977 VP	222	void
	223	mi_cmd_stack_list_variables (char command, char *argv, int argc)
	224	{
	225	struct frame_info *frame;
daf3c977 VP	226
	227	if (argc != 1)
	228	error (_("Usage: PRINT_VALUES"));
	229
7a93fb82	230	frame = get_selected_frame (NULL);
daf3c977	231
7a93fb82	232	list_args_or_locals (all, parse_print_values (argv[0]), frame);
daf3c977 VP	233	}
	234
	235
fb40c209 AC	236	/* Print a list of the locals or the arguments for the currently
	237	selected frame. If the argument passed is 0, printonly the names
	238	of the variables, if an argument of 1 is passed, print the values
	239	as well. */
	240	static void
daf3c977	241	list_args_or_locals (enum what_to_list what, int values, struct frame_info *fi)
fb40c209 AC	242	{
	243	struct block *block;
	244	struct symbol *sym;
de4f826b	245	struct dict_iterator iter;
6ad4a2cf	246	struct cleanup *cleanup_list;
fb40c209	247	static struct ui_stream *stb = NULL;
f5ec2042	248	struct type *type;
daf3c977	249	char *name_of_result;
fb40c209 AC	250
	251	stb = ui_out_stream_new (uiout);
	252
ae767bfb	253	block = get_frame_block (fi, 0);
fb40c209	254
daf3c977 VP	255	switch (what)
	256	{
	257	case locals:
d6fd4674 PA	258	name_of_result = "locals";
d6fd4674 PA	259	break;
daf3c977	260	case arguments:
d6fd4674 PA	261	name_of_result = "args";
d6fd4674 PA	262	break;
daf3c977	263	case all:
d6fd4674 PA	264	name_of_result = "variables";
d6fd4674 PA	265	break;
654e7c1f	266	default:
d6fd4674 PA	267	internal_error (__FILE__, __LINE__,
d6fd4674 PA	268	"unexpected what_to_list: %d", (int) what);
daf3c977 VP	269	}
	270
	271	cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);
fb40c209 AC	272
	273	while (block != 0)
	274	{
de4f826b	275	ALL_BLOCK_SYMBOLS (block, iter, sym)
fb40c209	276	{
39bf4652 JB	277	int print_me = 0;
39bf4652 JB	278
fb40c209 AC	279	switch (SYMBOL_CLASS (sym))
	280	{
	281	default:
	282	case LOC_UNDEF: /* catches errors */
	283	case LOC_CONST: /* constant */
	284	case LOC_TYPEDEF: /* local typedef */
	285	case LOC_LABEL: /* local label */
	286	case LOC_BLOCK: /* local function */
	287	case LOC_CONST_BYTES: /* loc. byte seq. */
	288	case LOC_UNRESOLVED: /* unresolved static */
	289	case LOC_OPTIMIZED_OUT: /* optimized out */
	290	print_me = 0;
	291	break;
	292
	293	case LOC_ARG: /* argument */
	294	case LOC_REF_ARG: /* reference arg */
fb40c209	295	case LOC_REGPARM_ADDR: /* indirect register arg */
fb40c209	296	case LOC_LOCAL: /* stack local */
fb40c209 AC	297	case LOC_STATIC: /* static */
fb40c209 AC	298	case LOC_REGISTER: /* register */
4cf623b6	299	case LOC_COMPUTED: /* computed location */
daf3c977	300	if (what == all)
fb40c209	301	print_me = 1;
daf3c977 VP	302	else if (what == locals)
	303	print_me = !SYMBOL_IS_ARGUMENT (sym);
	304	else
	305	print_me = SYMBOL_IS_ARGUMENT (sym);
fb40c209 AC	306	break;
	307	}
	308	if (print_me)
	309	{
6ad4a2cf	310	struct cleanup *cleanup_tuple = NULL;
6bb0384f	311	struct symbol *sym2;
9fbcbb40	312	struct value *val;
102040f0	313
7a93fb82	314	if (values != PRINT_NO_VALUES \|\| what == all)
f5ec2042	315	cleanup_tuple =
6ad4a2cf	316	make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
f5ec2042	317	ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
7a93fb82 VP	318	if (what == all && SYMBOL_IS_ARGUMENT (sym))
7a93fb82 VP	319	ui_out_field_int (uiout, "arg", 1);
fb40c209	320
daf3c977	321	if (SYMBOL_IS_ARGUMENT (sym))
f5ec2042 NR	322	sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
f5ec2042 NR	323	block, VAR_DOMAIN,
2570f2b7	324	(int *) NULL);
f5ec2042	325	else
2a2d4dc3	326	sym2 = sym;
f5ec2042 NR	327	switch (values)
	328	{
	329	case PRINT_SIMPLE_VALUES:
	330	type = check_typedef (sym2->type);
	331	type_print (sym2->type, "", stb->stream, -1);
	332	ui_out_field_stream (uiout, "type", stb);
	333	if (TYPE_CODE (type) != TYPE_CODE_ARRAY
	334	&& TYPE_CODE (type) != TYPE_CODE_STRUCT
	335	&& TYPE_CODE (type) != TYPE_CODE_UNION)
	336	{
875b4ff5 PM	337	volatile struct gdb_exception except;
	338
	339	TRY_CATCH (except, RETURN_MASK_ERROR)
	340	{
	341	struct value_print_options opts;
	342
	343	val = read_var_value (sym2, fi);
	344	get_raw_print_options (&opts);
	345	opts.deref_ref = 1;
	346	common_val_print
	347	(val, stb->stream, 0, &opts,
	348	language_def (SYMBOL_LANGUAGE (sym2)));
	349	}
	350	if (except.reason < 0)
	351	fprintf_filtered (stb->stream,
	352	_("<error reading variable: %s>"),
	353	except.message);
	354
f5ec2042 NR	355	ui_out_field_stream (uiout, "value", stb);
f5ec2042 NR	356	}
f5ec2042 NR	357	break;
f5ec2042 NR	358	case PRINT_ALL_VALUES:
79a45b7d	359	{
875b4ff5 PM	360	volatile struct gdb_exception except;
	361
	362	TRY_CATCH (except, RETURN_MASK_ERROR)
	363	{
	364	struct value_print_options opts;
	365
	366	val = read_var_value (sym2, fi);
	367	get_raw_print_options (&opts);
	368	opts.deref_ref = 1;
	369	common_val_print
	370	(val, stb->stream, 0, &opts,
	371	language_def (SYMBOL_LANGUAGE (sym2)));
	372	}
	373	if (except.reason < 0)
	374	fprintf_filtered (stb->stream,
	375	_("<error reading variable: %s>"),
	376	except.message);
	377
79a45b7d	378	ui_out_field_stream (uiout, "value", stb);
79a45b7d	379	}
f5ec2042	380	break;
fb40c209	381	}
7a93fb82 VP	382
	383	if (values != PRINT_NO_VALUES \|\| what == all)
	384	do_cleanups (cleanup_tuple);
fb40c209 AC	385	}
	386	}
	387	if (BLOCK_FUNCTION (block))
	388	break;
	389	else
	390	block = BLOCK_SUPERBLOCK (block);
	391	}
6ad4a2cf	392	do_cleanups (cleanup_list);
fb40c209 AC	393	ui_out_stream_delete (stb);
	394	}
	395
ce8f13f8	396	void
fb40c209 AC	397	mi_cmd_stack_select_frame (char command, char *argv, int argc)
fb40c209 AC	398	{
fcf43932 NR	399	if (argc == 0 \|\| argc > 1)
fcf43932 NR	400	error (_("mi_cmd_stack_select_frame: Usage: FRAME_SPEC"));
fb40c209	401
fcf43932	402	select_frame_command (argv[0], 1 /* not used */ );
fb40c209	403	}
64fd8944	404
ce8f13f8	405	void
64fd8944 NR	406	mi_cmd_stack_info_frame (char command, char *argv, int argc)
	407	{
	408	if (argc > 0)
	409	error (_("mi_cmd_stack_info_frame: No arguments required"));
ce8f13f8	410
64fd8944	411	print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
64fd8944	412	}