[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
   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"


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)
		    {
		      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)));
		      ui_out_field_stream (uiout, "value", stb);
		    }
		  break;
		case PRINT_ALL_VALUES:
		  {
		    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)));
		    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.
4c38e0a4	2	Copyright (C) 2000, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
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"
fb40c209	34
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;
fb40c209	207	QUIT;
6ad4a2cf	208	cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
fb40c209	209	ui_out_field_int (uiout, "level", i);
daf3c977	210	list_args_or_locals (arguments, print_values, fi);
6ad4a2cf	211	do_cleanups (cleanup_frame);
fb40c209 AC	212	}
fb40c209 AC	213
6ad4a2cf	214	do_cleanups (cleanup_stack_args);
fb40c209 AC	215	}
fb40c209 AC	216
daf3c977	217	/* Print a list of the local variables (including arguments) for the
7a93fb82 VP	218	current frame. ARGC must be 1 and ARGV[0] specify if only the names,
	219	or both names and values of the variables must be printed. See
	220	parse_print_value for possible values. */
daf3c977 VP	221	void
	222	mi_cmd_stack_list_variables (char command, char *argv, int argc)
	223	{
	224	struct frame_info *frame;
daf3c977 VP	225
	226	if (argc != 1)
	227	error (_("Usage: PRINT_VALUES"));
	228
7a93fb82	229	frame = get_selected_frame (NULL);
daf3c977	230
7a93fb82	231	list_args_or_locals (all, parse_print_values (argv[0]), frame);
daf3c977 VP	232	}
	233
	234
fb40c209 AC	235	/* Print a list of the locals or the arguments for the currently
	236	selected frame. If the argument passed is 0, printonly the names
	237	of the variables, if an argument of 1 is passed, print the values
	238	as well. */
	239	static void
daf3c977	240	list_args_or_locals (enum what_to_list what, int values, struct frame_info *fi)
fb40c209 AC	241	{
	242	struct block *block;
	243	struct symbol *sym;
de4f826b	244	struct dict_iterator iter;
6ad4a2cf	245	struct cleanup *cleanup_list;
fb40c209	246	static struct ui_stream *stb = NULL;
f5ec2042	247	struct type *type;
daf3c977	248	char *name_of_result;
fb40c209 AC	249
	250	stb = ui_out_stream_new (uiout);
	251
ae767bfb	252	block = get_frame_block (fi, 0);
fb40c209	253
daf3c977 VP	254	switch (what)
	255	{
	256	case locals:
d6fd4674 PA	257	name_of_result = "locals";
d6fd4674 PA	258	break;
daf3c977	259	case arguments:
d6fd4674 PA	260	name_of_result = "args";
d6fd4674 PA	261	break;
daf3c977	262	case all:
d6fd4674 PA	263	name_of_result = "variables";
d6fd4674 PA	264	break;
654e7c1f	265	default:
d6fd4674 PA	266	internal_error (__FILE__, __LINE__,
d6fd4674 PA	267	"unexpected what_to_list: %d", (int) what);
daf3c977 VP	268	}
	269
	270	cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result);
fb40c209 AC	271
	272	while (block != 0)
	273	{
de4f826b	274	ALL_BLOCK_SYMBOLS (block, iter, sym)
fb40c209	275	{
39bf4652 JB	276	int print_me = 0;
39bf4652 JB	277
fb40c209 AC	278	switch (SYMBOL_CLASS (sym))
	279	{
	280	default:
	281	case LOC_UNDEF: /* catches errors */
	282	case LOC_CONST: /* constant */
	283	case LOC_TYPEDEF: /* local typedef */
	284	case LOC_LABEL: /* local label */
	285	case LOC_BLOCK: /* local function */
	286	case LOC_CONST_BYTES: /* loc. byte seq. */
	287	case LOC_UNRESOLVED: /* unresolved static */
	288	case LOC_OPTIMIZED_OUT: /* optimized out */
	289	print_me = 0;
	290	break;
	291
	292	case LOC_ARG: /* argument */
	293	case LOC_REF_ARG: /* reference arg */
fb40c209	294	case LOC_REGPARM_ADDR: /* indirect register arg */
fb40c209	295	case LOC_LOCAL: /* stack local */
fb40c209 AC	296	case LOC_STATIC: /* static */
fb40c209 AC	297	case LOC_REGISTER: /* register */
4cf623b6	298	case LOC_COMPUTED: /* computed location */
daf3c977	299	if (what == all)
fb40c209	300	print_me = 1;
daf3c977 VP	301	else if (what == locals)
	302	print_me = !SYMBOL_IS_ARGUMENT (sym);
	303	else
	304	print_me = SYMBOL_IS_ARGUMENT (sym);
fb40c209 AC	305	break;
	306	}
	307	if (print_me)
	308	{
6ad4a2cf	309	struct cleanup *cleanup_tuple = NULL;
6bb0384f	310	struct symbol *sym2;
9fbcbb40	311	struct value *val;
7a93fb82	312	if (values != PRINT_NO_VALUES \|\| what == all)
f5ec2042	313	cleanup_tuple =
6ad4a2cf	314	make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
f5ec2042	315	ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym));
7a93fb82 VP	316	if (what == all && SYMBOL_IS_ARGUMENT (sym))
7a93fb82 VP	317	ui_out_field_int (uiout, "arg", 1);
fb40c209	318
daf3c977	319	if (SYMBOL_IS_ARGUMENT (sym))
f5ec2042 NR	320	sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
f5ec2042 NR	321	block, VAR_DOMAIN,
2570f2b7	322	(int *) NULL);
f5ec2042	323	else
2a2d4dc3	324	sym2 = sym;
f5ec2042 NR	325	switch (values)
	326	{
	327	case PRINT_SIMPLE_VALUES:
	328	type = check_typedef (sym2->type);
	329	type_print (sym2->type, "", stb->stream, -1);
	330	ui_out_field_stream (uiout, "type", stb);
	331	if (TYPE_CODE (type) != TYPE_CODE_ARRAY
	332	&& TYPE_CODE (type) != TYPE_CODE_STRUCT
	333	&& TYPE_CODE (type) != TYPE_CODE_UNION)
	334	{
79a45b7d	335	struct value_print_options opts;
9fbcbb40	336	val = read_var_value (sym2, fi);
79a45b7d TT	337	get_raw_print_options (&opts);
79a45b7d TT	338	opts.deref_ref = 1;
9fbcbb40	339	common_val_print
79a45b7d	340	(val, stb->stream, 0, &opts,
d8ca156b	341	language_def (SYMBOL_LANGUAGE (sym2)));
f5ec2042 NR	342	ui_out_field_stream (uiout, "value", stb);
f5ec2042 NR	343	}
f5ec2042 NR	344	break;
f5ec2042 NR	345	case PRINT_ALL_VALUES:
79a45b7d TT	346	{
	347	struct value_print_options opts;
	348	val = read_var_value (sym2, fi);
	349	get_raw_print_options (&opts);
	350	opts.deref_ref = 1;
	351	common_val_print
	352	(val, stb->stream, 0, &opts,
	353	language_def (SYMBOL_LANGUAGE (sym2)));
	354	ui_out_field_stream (uiout, "value", stb);
79a45b7d	355	}
f5ec2042	356	break;
fb40c209	357	}
7a93fb82 VP	358
	359	if (values != PRINT_NO_VALUES \|\| what == all)
	360	do_cleanups (cleanup_tuple);
fb40c209 AC	361	}
	362	}
	363	if (BLOCK_FUNCTION (block))
	364	break;
	365	else
	366	block = BLOCK_SUPERBLOCK (block);
	367	}
6ad4a2cf	368	do_cleanups (cleanup_list);
fb40c209 AC	369	ui_out_stream_delete (stb);
	370	}
	371
ce8f13f8	372	void
fb40c209 AC	373	mi_cmd_stack_select_frame (char command, char *argv, int argc)
fb40c209 AC	374	{
fcf43932 NR	375	if (argc == 0 \|\| argc > 1)
fcf43932 NR	376	error (_("mi_cmd_stack_select_frame: Usage: FRAME_SPEC"));
fb40c209	377
fcf43932	378	select_frame_command (argv[0], 1 /* not used */ );
fb40c209	379	}
64fd8944	380
ce8f13f8	381	void
64fd8944 NR	382	mi_cmd_stack_info_frame (char command, char *argv, int argc)
	383	{
	384	if (argc > 0)
	385	error (_("mi_cmd_stack_info_frame: No arguments required"));
ce8f13f8	386
64fd8944	387	print_frame_info (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 0);
64fd8944	388	}