[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 (_("-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 (_("-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 (_("-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 (_("-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 (_("-stack-list-arguments: 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 (_("-stack-list-arguments: 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 (_("-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 (_("-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)
1b05df00	56	error (_("-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)
1b05df00	79	error (_("-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)
1b05df00	106	error (_("-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)
1b05df00	150	error (_("-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)
1b05df00	171	error (_("-stack-list-arguments: Usage: "
9a2b4c1b	172	"PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
fb40c209 AC	173
	174	if (argc == 3)
	175	{
	176	frame_low = atoi (argv[1]);
	177	frame_high = atoi (argv[2]);
	178	}
	179	else
	180	{
	181	/* Called with no arguments, it means we want args for the whole
	182	backtrace. */
	183	frame_low = -1;
	184	frame_high = -1;
	185	}
	186
8b777f02 VP	187	print_values = parse_print_values (argv[0]);
8b777f02 VP	188
fb40c209 AC	189	/* Let's position fi on the frame at which to start the
	190	display. Could be the innermost frame if the whole stack needs
	191	displaying, or if frame_low is 0. */
	192	for (i = 0, fi = get_current_frame ();
	193	fi && i < frame_low;
	194	i++, fi = get_prev_frame (fi));
	195
	196	if (fi == NULL)
1b05df00	197	error (_("-stack-list-arguments: Not enough frames in stack."));
fb40c209	198
9a2b4c1b MS	199	cleanup_stack_args
9a2b4c1b MS	200	= make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
fb40c209 AC	201
	202	/* Now let's print the frames up to frame_high, or until there are
	203	frames in the stack. */
	204	for (;
	205	fi && (i <= frame_high \|\| frame_high == -1);
	206	i++, fi = get_prev_frame (fi))
	207	{
6ad4a2cf	208	struct cleanup *cleanup_frame;
102040f0	209
fb40c209	210	QUIT;
6ad4a2cf	211	cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
fb40c209	212	ui_out_field_int (uiout, "level", i);
daf3c977	213	list_args_or_locals (arguments, print_values, fi);
6ad4a2cf	214	do_cleanups (cleanup_frame);
fb40c209 AC	215	}
fb40c209 AC	216
6ad4a2cf	217	do_cleanups (cleanup_stack_args);
fb40c209 AC	218	}
fb40c209 AC	219
daf3c977	220	/* Print a list of the local variables (including arguments) for the
7a93fb82 VP	221	current frame. ARGC must be 1 and ARGV[0] specify if only the names,
	222	or both names and values of the variables must be printed. See
	223	parse_print_value for possible values. */
daf3c977 VP	224	void
	225	mi_cmd_stack_list_variables (char command, char *argv, int argc)
	226	{
	227	struct frame_info *frame;
daf3c977 VP	228
	229	if (argc != 1)
	230	error (_("Usage: PRINT_VALUES"));
	231
7a93fb82	232	frame = get_selected_frame (NULL);
daf3c977	233
7a93fb82	234	list_args_or_locals (all, parse_print_values (argv[0]), frame);
daf3c977 VP	235	}
	236
	237
fb40c209 AC	238	/* Print a list of the locals or the arguments for the currently
	239	selected frame. If the argument passed is 0, printonly the names
	240	of the variables, if an argument of 1 is passed, print the values
	241	as well. */
	242	static void
daf3c977	243	list_args_or_locals (enum what_to_list what, int values, struct frame_info *fi)
fb40c209 AC	244	{
	245	struct block *block;
	246	struct symbol *sym;
de4f826b	247	struct dict_iterator iter;
6ad4a2cf	248	struct cleanup *cleanup_list;
fb40c209	249	static struct ui_stream *stb = NULL;
f5ec2042	250	struct type *type;
daf3c977	251	char *name_of_result;
fb40c209 AC	252
	253	stb = ui_out_stream_new (uiout);
	254
ae767bfb	255	block = get_frame_block (fi, 0);
fb40c209	256
daf3c977 VP	257	switch (what)
	258	{
	259	case locals:
d6fd4674 PA	260	name_of_result = "locals";
d6fd4674 PA	261	break;
daf3c977	262	case arguments:
d6fd4674 PA	263	name_of_result = "args";
d6fd4674 PA	264	break;
daf3c977	265	case all:
d6fd4674 PA	266	name_of_result = "variables";
d6fd4674 PA	267	break;
654e7c1f	268	default:
d6fd4674 PA	269	internal_error (__FILE__, __LINE__,
d6fd4674 PA	270	"unexpected what_to_list: %d", (int) what);
daf3c977 VP	271	}
	272
	273	cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);
fb40c209 AC	274
	275	while (block != 0)
	276	{
de4f826b	277	ALL_BLOCK_SYMBOLS (block, iter, sym)
fb40c209	278	{
39bf4652 JB	279	int print_me = 0;
39bf4652 JB	280
fb40c209 AC	281	switch (SYMBOL_CLASS (sym))
	282	{
	283	default:
	284	case LOC_UNDEF: /* catches errors */
	285	case LOC_CONST: /* constant */
	286	case LOC_TYPEDEF: /* local typedef */
	287	case LOC_LABEL: /* local label */
	288	case LOC_BLOCK: /* local function */
	289	case LOC_CONST_BYTES: /* loc. byte seq. */
	290	case LOC_UNRESOLVED: /* unresolved static */
	291	case LOC_OPTIMIZED_OUT: /* optimized out */
	292	print_me = 0;
	293	break;
	294
	295	case LOC_ARG: /* argument */
	296	case LOC_REF_ARG: /* reference arg */
fb40c209	297	case LOC_REGPARM_ADDR: /* indirect register arg */
fb40c209	298	case LOC_LOCAL: /* stack local */
fb40c209 AC	299	case LOC_STATIC: /* static */
fb40c209 AC	300	case LOC_REGISTER: /* register */
4cf623b6	301	case LOC_COMPUTED: /* computed location */
daf3c977	302	if (what == all)
fb40c209	303	print_me = 1;
daf3c977 VP	304	else if (what == locals)
	305	print_me = !SYMBOL_IS_ARGUMENT (sym);
	306	else
	307	print_me = SYMBOL_IS_ARGUMENT (sym);
fb40c209 AC	308	break;
	309	}
	310	if (print_me)
	311	{
6ad4a2cf	312	struct cleanup *cleanup_tuple = NULL;
6bb0384f	313	struct symbol *sym2;
9fbcbb40	314	struct value *val;
102040f0	315
7a93fb82	316	if (values != PRINT_NO_VALUES \|\| what == all)
f5ec2042	317	cleanup_tuple =
6ad4a2cf	318	make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
f5ec2042	319	ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
7a93fb82 VP	320	if (what == all && SYMBOL_IS_ARGUMENT (sym))
7a93fb82 VP	321	ui_out_field_int (uiout, "arg", 1);
fb40c209	322
daf3c977	323	if (SYMBOL_IS_ARGUMENT (sym))
f5ec2042 NR	324	sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
f5ec2042 NR	325	block, VAR_DOMAIN,
2570f2b7	326	(int *) NULL);
f5ec2042	327	else
2a2d4dc3	328	sym2 = sym;
f5ec2042 NR	329	switch (values)
	330	{
	331	case PRINT_SIMPLE_VALUES:
	332	type = check_typedef (sym2->type);
	333	type_print (sym2->type, "", stb->stream, -1);
	334	ui_out_field_stream (uiout, "type", stb);
	335	if (TYPE_CODE (type) != TYPE_CODE_ARRAY
	336	&& TYPE_CODE (type) != TYPE_CODE_STRUCT
	337	&& TYPE_CODE (type) != TYPE_CODE_UNION)
	338	{
875b4ff5 PM	339	volatile struct gdb_exception except;
	340
	341	TRY_CATCH (except, RETURN_MASK_ERROR)
	342	{
	343	struct value_print_options opts;
	344
	345	val = read_var_value (sym2, fi);
	346	get_raw_print_options (&opts);
	347	opts.deref_ref = 1;
	348	common_val_print
	349	(val, stb->stream, 0, &opts,
	350	language_def (SYMBOL_LANGUAGE (sym2)));
	351	}
	352	if (except.reason < 0)
	353	fprintf_filtered (stb->stream,
	354	_("<error reading variable: %s>"),
	355	except.message);
	356
f5ec2042 NR	357	ui_out_field_stream (uiout, "value", stb);
f5ec2042 NR	358	}
f5ec2042 NR	359	break;
f5ec2042 NR	360	case PRINT_ALL_VALUES:
79a45b7d	361	{
875b4ff5 PM	362	volatile struct gdb_exception except;
	363
	364	TRY_CATCH (except, RETURN_MASK_ERROR)
	365	{
	366	struct value_print_options opts;
	367
	368	val = read_var_value (sym2, fi);
	369	get_raw_print_options (&opts);
	370	opts.deref_ref = 1;
	371	common_val_print
	372	(val, stb->stream, 0, &opts,
	373	language_def (SYMBOL_LANGUAGE (sym2)));
	374	}
	375	if (except.reason < 0)
	376	fprintf_filtered (stb->stream,
	377	_("<error reading variable: %s>"),
	378	except.message);
	379
79a45b7d	380	ui_out_field_stream (uiout, "value", stb);
79a45b7d	381	}
f5ec2042	382	break;
fb40c209	383	}
7a93fb82 VP	384
	385	if (values != PRINT_NO_VALUES \|\| what == all)
	386	do_cleanups (cleanup_tuple);
fb40c209 AC	387	}
	388	}
	389	if (BLOCK_FUNCTION (block))
	390	break;
	391	else
	392	block = BLOCK_SUPERBLOCK (block);
	393	}
6ad4a2cf	394	do_cleanups (cleanup_list);
fb40c209 AC	395	ui_out_stream_delete (stb);
	396	}
	397
ce8f13f8	398	void
fb40c209 AC	399	mi_cmd_stack_select_frame (char command, char *argv, int argc)
fb40c209 AC	400	{
fcf43932	401	if (argc == 0 \|\| argc > 1)
1b05df00	402	error (_("-stack-select-frame: Usage: FRAME_SPEC"));
fb40c209	403
fcf43932	404	select_frame_command (argv[0], 1 /* not used */ );
fb40c209	405	}
64fd8944	406
ce8f13f8	407	void
64fd8944 NR	408	mi_cmd_stack_info_frame (char command, char *argv, int argc)
	409	{
	410	if (argc > 0)
1b05df00	411	error (_("-stack-info-frame: No arguments required"));
ce8f13f8	412
64fd8944	413	print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
64fd8944	414	}