1/* Print values for GNU debugger GDB.
2
3   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5   Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.  */
21
22#include "defs.h"
23#include "gdb_string.h"
24#include "frame.h"
25#include "symtab.h"
26#include "gdbtypes.h"
27#include "value.h"
28#include "language.h"
29#include "expression.h"
30#include "gdbcore.h"
31#include "gdbcmd.h"
32#include "target.h"
33#include "breakpoint.h"
34#include "demangle.h"
35#include "valprint.h"
36#include "annotate.h"
37#include "symfile.h"		/* for overlay functions */
38#include "objfiles.h"		/* ditto */
39#include "completer.h"		/* for completion functions */
40#include "ui-out.h"
41#include "gdb_assert.h"
42#include "block.h"
43#include "disasm.h"
44
45#ifdef TUI
46#include "tui/tui.h"		/* For tui_active et.al.   */
47#endif
48
49extern int asm_demangle;	/* Whether to demangle syms in asm printouts */
50extern int addressprint;	/* Whether to print hex addresses in HLL " */
51
52struct format_data
53  {
54    int count;
55    char format;
56    char size;
57  };
58
59/* Last specified output format.  */
60
61static char last_format = 'x';
62
63/* Last specified examination size.  'b', 'h', 'w' or `q'.  */
64
65static char last_size = 'w';
66
67/* Default address to examine next.  */
68
69static CORE_ADDR next_address;
70
71/* Number of delay instructions following current disassembled insn.  */
72
73static int branch_delay_insns;
74
75/* Last address examined.  */
76
77static CORE_ADDR last_examine_address;
78
79/* Contents of last address examined.
80   This is not valid past the end of the `x' command!  */
81
82static struct value *last_examine_value;
83
84/* Largest offset between a symbolic value and an address, that will be
85   printed as `0x1234 <symbol+offset>'.  */
86
87static unsigned int max_symbolic_offset = UINT_MAX;
88static void
89show_max_symbolic_offset (struct ui_file *file, int from_tty,
90			  struct cmd_list_element *c, const char *value)
91{
92  fprintf_filtered (file, _("\
93The largest offset that will be printed in <symbol+1234> form is %s.\n"),
94		    value);
95}
96
97/* Append the source filename and linenumber of the symbol when
98   printing a symbolic value as `<symbol at filename:linenum>' if set.  */
99static int print_symbol_filename = 0;
100static void
101show_print_symbol_filename (struct ui_file *file, int from_tty,
102			    struct cmd_list_element *c, const char *value)
103{
104  fprintf_filtered (file, _("\
105Printing of source filename and line number with <symbol> is %s.\n"),
106		    value);
107}
108
109/* Number of auto-display expression currently being displayed.
110   So that we can disable it if we get an error or a signal within it.
111   -1 when not doing one.  */
112
113int current_display_number;
114
115/* Flag to low-level print routines that this value is being printed
116   in an epoch window.  We'd like to pass this as a parameter, but
117   every routine would need to take it.  Perhaps we can encapsulate
118   this in the I/O stream once we have GNU stdio. */
119
120int inspect_it = 0;
121
122struct display
123  {
124    /* Chain link to next auto-display item.  */
125    struct display *next;
126    /* Expression to be evaluated and displayed.  */
127    struct expression *exp;
128    /* Item number of this auto-display item.  */
129    int number;
130    /* Display format specified.  */
131    struct format_data format;
132    /* Innermost block required by this expression when evaluated */
133    struct block *block;
134    /* Status of this display (enabled or disabled) */
135    int enabled_p;
136  };
137
138/* Chain of expressions whose values should be displayed
139   automatically each time the program stops.  */
140
141static struct display *display_chain;
142
143static int display_number;
144
145/* Prototypes for exported functions. */
146
147void output_command (char *, int);
148
149void _initialize_printcmd (void);
150
151/* Prototypes for local functions. */
152
153static void do_one_display (struct display *);
154
155
156/* Decode a format specification.  *STRING_PTR should point to it.
157   OFORMAT and OSIZE are used as defaults for the format and size
158   if none are given in the format specification.
159   If OSIZE is zero, then the size field of the returned value
160   should be set only if a size is explicitly specified by the
161   user.
162   The structure returned describes all the data
163   found in the specification.  In addition, *STRING_PTR is advanced
164   past the specification and past all whitespace following it.  */
165
166static struct format_data
167decode_format (char **string_ptr, int oformat, int osize)
168{
169  struct format_data val;
170  char *p = *string_ptr;
171
172  val.format = '?';
173  val.size = '?';
174  val.count = 1;
175
176  if (*p >= '0' && *p <= '9')
177    val.count = atoi (p);
178  while (*p >= '0' && *p <= '9')
179    p++;
180
181  /* Now process size or format letters that follow.  */
182
183  while (1)
184    {
185      if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
186	val.size = *p++;
187      else if (*p >= 'a' && *p <= 'z')
188	val.format = *p++;
189      else
190	break;
191    }
192
193  while (*p == ' ' || *p == '\t')
194    p++;
195  *string_ptr = p;
196
197  /* Set defaults for format and size if not specified.  */
198  if (val.format == '?')
199    {
200      if (val.size == '?')
201	{
202	  /* Neither has been specified.  */
203	  val.format = oformat;
204	  val.size = osize;
205	}
206      else
207	/* If a size is specified, any format makes a reasonable
208	   default except 'i'.  */
209	val.format = oformat == 'i' ? 'x' : oformat;
210    }
211  else if (val.size == '?')
212    switch (val.format)
213      {
214      case 'a':
215      case 's':
216	/* Pick the appropriate size for an address.  */
217	if (gdbarch_ptr_bit (current_gdbarch) == 64)
218	  val.size = osize ? 'g' : osize;
219	else if (gdbarch_ptr_bit (current_gdbarch) == 32)
220	  val.size = osize ? 'w' : osize;
221	else if (gdbarch_ptr_bit (current_gdbarch) == 16)
222	  val.size = osize ? 'h' : osize;
223	else
224	  /* Bad value for gdbarch_ptr_bit.  */
225	  internal_error (__FILE__, __LINE__,
226			  _("failed internal consistency check"));
227	break;
228      case 'f':
229	/* Floating point has to be word or giantword.  */
230	if (osize == 'w' || osize == 'g')
231	  val.size = osize;
232	else
233	  /* Default it to giantword if the last used size is not
234	     appropriate.  */
235	  val.size = osize ? 'g' : osize;
236	break;
237      case 'c':
238	/* Characters default to one byte.  */
239	val.size = osize ? 'b' : osize;
240	break;
241      default:
242	/* The default is the size most recently specified.  */
243	val.size = osize;
244      }
245
246  return val;
247}
248
249/* Print value VAL on stream according to FORMAT, a letter or 0.
250   Do not end with a newline.
251   0 means print VAL according to its own type.
252   SIZE is the letter for the size of datum being printed.
253   This is used to pad hex numbers so they line up.  SIZE is 0
254   for print / output and set for examine.  */
255
256static void
257print_formatted (struct value *val, int format, int size,
258		 struct ui_file *stream)
259{
260  struct type *type = check_typedef (value_type (val));
261  int len = TYPE_LENGTH (type);
262
263  if (VALUE_LVAL (val) == lval_memory)
264    next_address = VALUE_ADDRESS (val) + len;
265
266  if (size)
267    {
268      switch (format)
269	{
270	case 's':
271	  /* FIXME: Need to handle wchar_t's here... */
272	  next_address = VALUE_ADDRESS (val)
273	    + val_print_string (VALUE_ADDRESS (val), -1, 1, stream);
274	  return;
275
276	case 'i':
277	  /* We often wrap here if there are long symbolic names.  */
278	  wrap_here ("    ");
279	  next_address = (VALUE_ADDRESS (val)
280			  + gdb_print_insn (VALUE_ADDRESS (val), stream,
281					    &branch_delay_insns));
282	  return;
283	}
284    }
285
286  if (format == 0 || format == 's'
287      || TYPE_CODE (type) == TYPE_CODE_ARRAY
288      || TYPE_CODE (type) == TYPE_CODE_STRING
289      || TYPE_CODE (type) == TYPE_CODE_STRUCT
290      || TYPE_CODE (type) == TYPE_CODE_UNION
291      || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
292    /* If format is 0, use the 'natural' format for that type of
293       value.  If the type is non-scalar, we have to use language
294       rules to print it as a series of scalars.  */
295    value_print (val, stream, format, Val_pretty_default);
296  else
297    /* User specified format, so don't look to the the type to
298       tell us what to do.  */
299    print_scalar_formatted (value_contents (val), type,
300			    format, size, stream);
301}
302
303/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
304   according to letters FORMAT and SIZE on STREAM.
305   FORMAT may not be zero.  Formats s and i are not supported at this level.
306
307   This is how the elements of an array or structure are printed
308   with a format.  */
309
310void
311print_scalar_formatted (const void *valaddr, struct type *type,
312			int format, int size, struct ui_file *stream)
313{
314  LONGEST val_long = 0;
315  unsigned int len = TYPE_LENGTH (type);
316
317  /* If we get here with a string format, try again without it.  Go
318     all the way back to the language printers, which may call us
319     again.  */
320  if (format == 's')
321    {
322      val_print (type, valaddr, 0, 0, stream, 0, 0, 0, Val_pretty_default);
323      return;
324    }
325
326  if (len > sizeof(LONGEST) &&
327      (TYPE_CODE (type) == TYPE_CODE_INT
328       || TYPE_CODE (type) == TYPE_CODE_ENUM))
329    {
330      switch (format)
331	{
332	case 'o':
333	  print_octal_chars (stream, valaddr, len);
334	  return;
335	case 'u':
336	case 'd':
337	  print_decimal_chars (stream, valaddr, len);
338	  return;
339	case 't':
340	  print_binary_chars (stream, valaddr, len);
341	  return;
342	case 'x':
343	  print_hex_chars (stream, valaddr, len);
344	  return;
345	case 'c':
346	  print_char_chars (stream, valaddr, len);
347	  return;
348	default:
349	  break;
350	};
351    }
352
353  if (format != 'f')
354    val_long = unpack_long (type, valaddr);
355
356  /* If the value is a pointer, and pointers and addresses are not the
357     same, then at this point, the value's length (in target bytes) is
358     gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type).  */
359  if (TYPE_CODE (type) == TYPE_CODE_PTR)
360    len = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT;
361
362  /* If we are printing it as unsigned, truncate it in case it is actually
363     a negative signed value (e.g. "print/u (short)-1" should print 65535
364     (if shorts are 16 bits) instead of 4294967295).  */
365  if (format != 'd')
366    {
367      if (len < sizeof (LONGEST))
368	val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
369    }
370
371  switch (format)
372    {
373    case 'x':
374      if (!size)
375	{
376	  /* No size specified, like in print.  Print varying # of digits.  */
377	  print_longest (stream, 'x', 1, val_long);
378	}
379      else
380	switch (size)
381	  {
382	  case 'b':
383	  case 'h':
384	  case 'w':
385	  case 'g':
386	    print_longest (stream, size, 1, val_long);
387	    break;
388	  default:
389	    error (_("Undefined output size \"%c\"."), size);
390	  }
391      break;
392
393    case 'd':
394      print_longest (stream, 'd', 1, val_long);
395      break;
396
397    case 'u':
398      print_longest (stream, 'u', 0, val_long);
399      break;
400
401    case 'o':
402      if (val_long)
403	print_longest (stream, 'o', 1, val_long);
404      else
405	fprintf_filtered (stream, "0");
406      break;
407
408    case 'a':
409      {
410	CORE_ADDR addr = unpack_pointer (type, valaddr);
411	print_address (addr, stream);
412      }
413      break;
414
415    case 'c':
416      if (TYPE_UNSIGNED (type))
417	{
418	  struct type *utype;
419
420	  utype = builtin_type (current_gdbarch)->builtin_true_unsigned_char;
421	  value_print (value_from_longest (utype, val_long),
422		       stream, 0, Val_pretty_default);
423	}
424      else
425	value_print (value_from_longest (builtin_type_true_char, val_long),
426		     stream, 0, Val_pretty_default);
427      break;
428
429    case 'f':
430      if (len == TYPE_LENGTH (builtin_type_float))
431        type = builtin_type_float;
432      else if (len == TYPE_LENGTH (builtin_type_double))
433        type = builtin_type_double;
434      else if (len == TYPE_LENGTH (builtin_type_long_double))
435        type = builtin_type_long_double;
436      print_floating (valaddr, type, stream);
437      break;
438
439    case 0:
440      internal_error (__FILE__, __LINE__,
441		      _("failed internal consistency check"));
442
443    case 't':
444      /* Binary; 't' stands for "two".  */
445      {
446	char bits[8 * (sizeof val_long) + 1];
447	char buf[8 * (sizeof val_long) + 32];
448	char *cp = bits;
449	int width;
450
451	if (!size)
452	  width = 8 * (sizeof val_long);
453	else
454	  switch (size)
455	    {
456	    case 'b':
457	      width = 8;
458	      break;
459	    case 'h':
460	      width = 16;
461	      break;
462	    case 'w':
463	      width = 32;
464	      break;
465	    case 'g':
466	      width = 64;
467	      break;
468	    default:
469	      error (_("Undefined output size \"%c\"."), size);
470	    }
471
472	bits[width] = '\0';
473	while (width-- > 0)
474	  {
475	    bits[width] = (val_long & 1) ? '1' : '0';
476	    val_long >>= 1;
477	  }
478	if (!size)
479	  {
480	    while (*cp && *cp == '0')
481	      cp++;
482	    if (*cp == '\0')
483	      cp--;
484	  }
485	strcpy (buf, cp);
486	fputs_filtered (buf, stream);
487      }
488      break;
489
490    default:
491      error (_("Undefined output format \"%c\"."), format);
492    }
493}
494
495/* Specify default address for `x' command.
496   The `info lines' command uses this.  */
497
498void
499set_next_address (CORE_ADDR addr)
500{
501  next_address = addr;
502
503  /* Make address available to the user as $_.  */
504  set_internalvar (lookup_internalvar ("_"),
505		   value_from_pointer (lookup_pointer_type (builtin_type_void),
506				       addr));
507}
508
509/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
510   after LEADIN.  Print nothing if no symbolic name is found nearby.
511   Optionally also print source file and line number, if available.
512   DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
513   or to interpret it as a possible C++ name and convert it back to source
514   form.  However note that DO_DEMANGLE can be overridden by the specific
515   settings of the demangle and asm_demangle variables.  */
516
517void
518print_address_symbolic (CORE_ADDR addr, struct ui_file *stream,
519			int do_demangle, char *leadin)
520{
521  char *name = NULL;
522  char *filename = NULL;
523  int unmapped = 0;
524  int offset = 0;
525  int line = 0;
526
527  /* Throw away both name and filename.  */
528  struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
529  make_cleanup (free_current_contents, &filename);
530
531  if (build_address_symbolic (addr, do_demangle, &name, &offset,
532			      &filename, &line, &unmapped))
533    {
534      do_cleanups (cleanup_chain);
535      return;
536    }
537
538  fputs_filtered (leadin, stream);
539  if (unmapped)
540    fputs_filtered ("<*", stream);
541  else
542    fputs_filtered ("<", stream);
543  fputs_filtered (name, stream);
544  if (offset != 0)
545    fprintf_filtered (stream, "+%u", (unsigned int) offset);
546
547  /* Append source filename and line number if desired.  Give specific
548     line # of this addr, if we have it; else line # of the nearest symbol.  */
549  if (print_symbol_filename && filename != NULL)
550    {
551      if (line != -1)
552	fprintf_filtered (stream, " at %s:%d", filename, line);
553      else
554	fprintf_filtered (stream, " in %s", filename);
555    }
556  if (unmapped)
557    fputs_filtered ("*>", stream);
558  else
559    fputs_filtered (">", stream);
560
561  do_cleanups (cleanup_chain);
562}
563
564/* Given an address ADDR return all the elements needed to print the
565   address in a symbolic form. NAME can be mangled or not depending
566   on DO_DEMANGLE (and also on the asm_demangle global variable,
567   manipulated via ''set print asm-demangle''). Return 0 in case of
568   success, when all the info in the OUT paramters is valid. Return 1
569   otherwise. */
570int
571build_address_symbolic (CORE_ADDR addr,  /* IN */
572			int do_demangle, /* IN */
573			char **name,     /* OUT */
574			int *offset,     /* OUT */
575			char **filename, /* OUT */
576			int *line,       /* OUT */
577			int *unmapped)   /* OUT */
578{
579  struct minimal_symbol *msymbol;
580  struct symbol *symbol;
581  CORE_ADDR name_location = 0;
582  asection *section = 0;
583  char *name_temp = "";
584
585  /* Let's say it is unmapped.  */
586  *unmapped = 0;
587
588  /* Determine if the address is in an overlay, and whether it is
589     mapped.  */
590  if (overlay_debugging)
591    {
592      section = find_pc_overlay (addr);
593      if (pc_in_unmapped_range (addr, section))
594	{
595	  *unmapped = 1;
596	  addr = overlay_mapped_address (addr, section);
597	}
598    }
599
600  /* First try to find the address in the symbol table, then
601     in the minsyms.  Take the closest one.  */
602
603  /* This is defective in the sense that it only finds text symbols.  So
604     really this is kind of pointless--we should make sure that the
605     minimal symbols have everything we need (by changing that we could
606     save some memory, but for many debug format--ELF/DWARF or
607     anything/stabs--it would be inconvenient to eliminate those minimal
608     symbols anyway).  */
609  msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
610  symbol = find_pc_sect_function (addr, section);
611
612  if (symbol)
613    {
614      name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
615      if (do_demangle || asm_demangle)
616	name_temp = SYMBOL_PRINT_NAME (symbol);
617      else
618	name_temp = DEPRECATED_SYMBOL_NAME (symbol);
619    }
620
621  if (msymbol != NULL)
622    {
623      if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
624	{
625	  /* The msymbol is closer to the address than the symbol;
626	     use the msymbol instead.  */
627	  symbol = 0;
628	  name_location = SYMBOL_VALUE_ADDRESS (msymbol);
629	  if (do_demangle || asm_demangle)
630	    name_temp = SYMBOL_PRINT_NAME (msymbol);
631	  else
632	    name_temp = DEPRECATED_SYMBOL_NAME (msymbol);
633	}
634    }
635  if (symbol == NULL && msymbol == NULL)
636    return 1;
637
638  /* If the nearest symbol is too far away, don't print anything symbolic.  */
639
640  /* For when CORE_ADDR is larger than unsigned int, we do math in
641     CORE_ADDR.  But when we detect unsigned wraparound in the
642     CORE_ADDR math, we ignore this test and print the offset,
643     because addr+max_symbolic_offset has wrapped through the end
644     of the address space back to the beginning, giving bogus comparison.  */
645  if (addr > name_location + max_symbolic_offset
646      && name_location + max_symbolic_offset > name_location)
647    return 1;
648
649  *offset = addr - name_location;
650
651  *name = xstrdup (name_temp);
652
653  if (print_symbol_filename)
654    {
655      struct symtab_and_line sal;
656
657      sal = find_pc_sect_line (addr, section, 0);
658
659      if (sal.symtab)
660	{
661	  *filename = xstrdup (sal.symtab->filename);
662	  *line = sal.line;
663	}
664    }
665  return 0;
666}
667
668/* Print address ADDR on STREAM.  USE_LOCAL means the same thing as for
669   print_longest.  */
670void
671deprecated_print_address_numeric (CORE_ADDR addr, int use_local,
672				  struct ui_file *stream)
673{
674  if (use_local)
675    fputs_filtered (paddress (addr), stream);
676  else
677    {
678      int addr_bit = gdbarch_addr_bit (current_gdbarch);
679
680      if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
681	addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
682      print_longest (stream, 'x', 0, (ULONGEST) addr);
683    }
684}
685
686/* Print address ADDR symbolically on STREAM.
687   First print it as a number.  Then perhaps print
688   <SYMBOL + OFFSET> after the number.  */
689
690void
691print_address (CORE_ADDR addr, struct ui_file *stream)
692{
693  deprecated_print_address_numeric (addr, 1, stream);
694  print_address_symbolic (addr, stream, asm_demangle, " ");
695}
696
697/* Print address ADDR symbolically on STREAM.  Parameter DEMANGLE
698   controls whether to print the symbolic name "raw" or demangled.
699   Global setting "addressprint" controls whether to print hex address
700   or not.  */
701
702void
703print_address_demangle (CORE_ADDR addr, struct ui_file *stream,
704			int do_demangle)
705{
706  if (addr == 0)
707    {
708      fprintf_filtered (stream, "0");
709    }
710  else if (addressprint)
711    {
712      deprecated_print_address_numeric (addr, 1, stream);
713      print_address_symbolic (addr, stream, do_demangle, " ");
714    }
715  else
716    {
717      print_address_symbolic (addr, stream, do_demangle, "");
718    }
719}
720
721
722/* These are the types that $__ will get after an examine command of one
723   of these sizes.  */
724
725static struct type *examine_i_type;
726
727static struct type *examine_b_type;
728static struct type *examine_h_type;
729static struct type *examine_w_type;
730static struct type *examine_g_type;
731
732/* Examine data at address ADDR in format FMT.
733   Fetch it from memory and print on gdb_stdout.  */
734
735static void
736do_examine (struct format_data fmt, CORE_ADDR addr)
737{
738  char format = 0;
739  char size;
740  int count = 1;
741  struct type *val_type = NULL;
742  int i;
743  int maxelts;
744
745  format = fmt.format;
746  size = fmt.size;
747  count = fmt.count;
748  next_address = addr;
749
750  /* String or instruction format implies fetch single bytes
751     regardless of the specified size.  */
752  if (format == 's' || format == 'i')
753    size = 'b';
754
755  if (format == 'i')
756    val_type = examine_i_type;
757  else if (size == 'b')
758    val_type = examine_b_type;
759  else if (size == 'h')
760    val_type = examine_h_type;
761  else if (size == 'w')
762    val_type = examine_w_type;
763  else if (size == 'g')
764    val_type = examine_g_type;
765
766  maxelts = 8;
767  if (size == 'w')
768    maxelts = 4;
769  if (size == 'g')
770    maxelts = 2;
771  if (format == 's' || format == 'i')
772    maxelts = 1;
773
774  /* Print as many objects as specified in COUNT, at most maxelts per line,
775     with the address of the next one at the start of each line.  */
776
777  while (count > 0)
778    {
779      QUIT;
780      print_address (next_address, gdb_stdout);
781      printf_filtered (":");
782      for (i = maxelts;
783	   i > 0 && count > 0;
784	   i--, count--)
785	{
786	  printf_filtered ("\t");
787	  /* Note that print_formatted sets next_address for the next
788	     object.  */
789	  last_examine_address = next_address;
790
791	  if (last_examine_value)
792	    value_free (last_examine_value);
793
794	  /* The value to be displayed is not fetched greedily.
795	     Instead, to avoid the possibility of a fetched value not
796	     being used, its retrieval is delayed until the print code
797	     uses it.  When examining an instruction stream, the
798	     disassembler will perform its own memory fetch using just
799	     the address stored in LAST_EXAMINE_VALUE.  FIXME: Should
800	     the disassembler be modified so that LAST_EXAMINE_VALUE
801	     is left with the byte sequence from the last complete
802	     instruction fetched from memory? */
803	  last_examine_value = value_at_lazy (val_type, next_address);
804
805	  if (last_examine_value)
806	    release_value (last_examine_value);
807
808	  print_formatted (last_examine_value, format, size, gdb_stdout);
809
810	  /* Display any branch delay slots following the final insn.  */
811	  if (format == 'i' && count == 1)
812	    count += branch_delay_insns;
813	}
814      printf_filtered ("\n");
815      gdb_flush (gdb_stdout);
816    }
817}
818
819static void
820validate_format (struct format_data fmt, char *cmdname)
821{
822  if (fmt.size != 0)
823    error (_("Size letters are meaningless in \"%s\" command."), cmdname);
824  if (fmt.count != 1)
825    error (_("Item count other than 1 is meaningless in \"%s\" command."),
826	   cmdname);
827  if (fmt.format == 'i')
828    error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
829	   fmt.format, cmdname);
830}
831
832/* Evaluate string EXP as an expression in the current language and
833   print the resulting value.  EXP may contain a format specifier as the
834   first argument ("/x myvar" for example, to print myvar in hex).  */
835
836static void
837print_command_1 (char *exp, int inspect, int voidprint)
838{
839  struct expression *expr;
840  struct cleanup *old_chain = 0;
841  char format = 0;
842  struct value *val;
843  struct format_data fmt;
844  int cleanup = 0;
845
846  /* Pass inspect flag to the rest of the print routines in a global
847     (sigh).  */
848  inspect_it = inspect;
849
850  if (exp && *exp == '/')
851    {
852      exp++;
853      fmt = decode_format (&exp, last_format, 0);
854      validate_format (fmt, "print");
855      last_format = format = fmt.format;
856    }
857  else
858    {
859      fmt.count = 1;
860      fmt.format = 0;
861      fmt.size = 0;
862    }
863
864  if (exp && *exp)
865    {
866      struct type *type;
867      expr = parse_expression (exp);
868      old_chain = make_cleanup (free_current_contents, &expr);
869      cleanup = 1;
870      val = evaluate_expression (expr);
871    }
872  else
873    val = access_value_history (0);
874
875  if (voidprint || (val && value_type (val) &&
876		    TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
877    {
878      int histindex = record_latest_value (val);
879
880      if (histindex >= 0)
881	annotate_value_history_begin (histindex, value_type (val));
882      else
883	annotate_value_begin (value_type (val));
884
885      if (inspect)
886	printf_unfiltered ("\031(gdb-makebuffer \"%s\"  %d '(\"",
887			   exp, histindex);
888      else if (histindex >= 0)
889	printf_filtered ("$%d = ", histindex);
890
891      if (histindex >= 0)
892	annotate_value_history_value ();
893
894      print_formatted (val, format, fmt.size, gdb_stdout);
895      printf_filtered ("\n");
896
897      if (histindex >= 0)
898	annotate_value_history_end ();
899      else
900	annotate_value_end ();
901
902      if (inspect)
903	printf_unfiltered ("\") )\030");
904    }
905
906  if (cleanup)
907    do_cleanups (old_chain);
908  inspect_it = 0;		/* Reset print routines to normal.  */
909}
910
911static void
912print_command (char *exp, int from_tty)
913{
914  print_command_1 (exp, 0, 1);
915}
916
917/* Same as print, except in epoch, it gets its own window.  */
918static void
919inspect_command (char *exp, int from_tty)
920{
921  extern int epoch_interface;
922
923  print_command_1 (exp, epoch_interface, 1);
924}
925
926/* Same as print, except it doesn't print void results.  */
927static void
928call_command (char *exp, int from_tty)
929{
930  print_command_1 (exp, 0, 0);
931}
932
933void
934output_command (char *exp, int from_tty)
935{
936  struct expression *expr;
937  struct cleanup *old_chain;
938  char format = 0;
939  struct value *val;
940  struct format_data fmt;
941
942  fmt.size = 0;
943
944  if (exp && *exp == '/')
945    {
946      exp++;
947      fmt = decode_format (&exp, 0, 0);
948      validate_format (fmt, "output");
949      format = fmt.format;
950    }
951
952  expr = parse_expression (exp);
953  old_chain = make_cleanup (free_current_contents, &expr);
954
955  val = evaluate_expression (expr);
956
957  annotate_value_begin (value_type (val));
958
959  print_formatted (val, format, fmt.size, gdb_stdout);
960
961  annotate_value_end ();
962
963  wrap_here ("");
964  gdb_flush (gdb_stdout);
965
966  do_cleanups (old_chain);
967}
968
969static void
970set_command (char *exp, int from_tty)
971{
972  struct expression *expr = parse_expression (exp);
973  struct cleanup *old_chain =
974    make_cleanup (free_current_contents, &expr);
975  evaluate_expression (expr);
976  do_cleanups (old_chain);
977}
978
979static void
980sym_info (char *arg, int from_tty)
981{
982  struct minimal_symbol *msymbol;
983  struct objfile *objfile;
984  struct obj_section *osect;
985  asection *sect;
986  CORE_ADDR addr, sect_addr;
987  int matches = 0;
988  unsigned int offset;
989
990  if (!arg)
991    error_no_arg (_("address"));
992
993  addr = parse_and_eval_address (arg);
994  ALL_OBJSECTIONS (objfile, osect)
995  {
996    /* Only process each object file once, even if there's a separate
997       debug file.  */
998    if (objfile->separate_debug_objfile_backlink)
999      continue;
1000
1001    sect = osect->the_bfd_section;
1002    sect_addr = overlay_mapped_address (addr, sect);
1003
1004    if (osect->addr <= sect_addr && sect_addr < osect->endaddr &&
1005	(msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, sect)))
1006      {
1007	matches = 1;
1008	offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
1009	if (offset)
1010	  printf_filtered ("%s + %u in ",
1011			   SYMBOL_PRINT_NAME (msymbol), offset);
1012	else
1013	  printf_filtered ("%s in ",
1014			   SYMBOL_PRINT_NAME (msymbol));
1015	if (pc_in_unmapped_range (addr, sect))
1016	  printf_filtered (_("load address range of "));
1017	if (section_is_overlay (sect))
1018	  printf_filtered (_("%s overlay "),
1019			   section_is_mapped (sect) ? "mapped" : "unmapped");
1020	printf_filtered (_("section %s"), sect->name);
1021	printf_filtered ("\n");
1022      }
1023  }
1024  if (matches == 0)
1025    printf_filtered (_("No symbol matches %s.\n"), arg);
1026}
1027
1028static void
1029address_info (char *exp, int from_tty)
1030{
1031  struct symbol *sym;
1032  struct minimal_symbol *msymbol;
1033  long val;
1034  long basereg;
1035  asection *section;
1036  CORE_ADDR load_addr;
1037  int is_a_field_of_this;	/* C++: lookup_symbol sets this to nonzero
1038				   if exp is a field of `this'. */
1039
1040  if (exp == 0)
1041    error (_("Argument required."));
1042
1043  sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
1044		       &is_a_field_of_this, (struct symtab **) NULL);
1045  if (sym == NULL)
1046    {
1047      if (is_a_field_of_this)
1048	{
1049	  printf_filtered ("Symbol \"");
1050	  fprintf_symbol_filtered (gdb_stdout, exp,
1051				   current_language->la_language, DMGL_ANSI);
1052	  printf_filtered ("\" is a field of the local class variable ");
1053	  if (current_language->la_language == language_objc)
1054	    printf_filtered ("`self'\n");	/* ObjC equivalent of "this" */
1055	  else
1056	    printf_filtered ("`this'\n");
1057	  return;
1058	}
1059
1060      msymbol = lookup_minimal_symbol (exp, NULL, NULL);
1061
1062      if (msymbol != NULL)
1063	{
1064	  load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1065
1066	  printf_filtered ("Symbol \"");
1067	  fprintf_symbol_filtered (gdb_stdout, exp,
1068				   current_language->la_language, DMGL_ANSI);
1069	  printf_filtered ("\" is at ");
1070	  deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1071	  printf_filtered (" in a file compiled without debugging");
1072	  section = SYMBOL_BFD_SECTION (msymbol);
1073	  if (section_is_overlay (section))
1074	    {
1075	      load_addr = overlay_unmapped_address (load_addr, section);
1076	      printf_filtered (",\n -- loaded at ");
1077	      deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1078	      printf_filtered (" in overlay section %s", section->name);
1079	    }
1080	  printf_filtered (".\n");
1081	}
1082      else
1083	error (_("No symbol \"%s\" in current context."), exp);
1084      return;
1085    }
1086
1087  printf_filtered ("Symbol \"");
1088  fprintf_symbol_filtered (gdb_stdout, DEPRECATED_SYMBOL_NAME (sym),
1089			   current_language->la_language, DMGL_ANSI);
1090  printf_filtered ("\" is ");
1091  val = SYMBOL_VALUE (sym);
1092  basereg = SYMBOL_BASEREG (sym);
1093  section = SYMBOL_BFD_SECTION (sym);
1094
1095  switch (SYMBOL_CLASS (sym))
1096    {
1097    case LOC_CONST:
1098    case LOC_CONST_BYTES:
1099      printf_filtered ("constant");
1100      break;
1101
1102    case LOC_LABEL:
1103      printf_filtered ("a label at address ");
1104      deprecated_print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1105			     1, gdb_stdout);
1106      if (section_is_overlay (section))
1107	{
1108	  load_addr = overlay_unmapped_address (load_addr, section);
1109	  printf_filtered (",\n -- loaded at ");
1110	  deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1111	  printf_filtered (" in overlay section %s", section->name);
1112	}
1113      break;
1114
1115    case LOC_COMPUTED:
1116    case LOC_COMPUTED_ARG:
1117      /* FIXME: cagney/2004-01-26: It should be possible to
1118	 unconditionally call the SYMBOL_OPS method when available.
1119	 Unfortunately DWARF 2 stores the frame-base (instead of the
1120	 function) location in a function's symbol.  Oops!  For the
1121	 moment enable this when/where applicable.  */
1122      SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout);
1123      break;
1124
1125    case LOC_REGISTER:
1126      printf_filtered (_("a variable in register %s"),
1127			 gdbarch_register_name (current_gdbarch, val));
1128      break;
1129
1130    case LOC_STATIC:
1131      printf_filtered (_("static storage at address "));
1132      deprecated_print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1133			     1, gdb_stdout);
1134      if (section_is_overlay (section))
1135	{
1136	  load_addr = overlay_unmapped_address (load_addr, section);
1137	  printf_filtered (_(",\n -- loaded at "));
1138	  deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1139	  printf_filtered (_(" in overlay section %s"), section->name);
1140	}
1141      break;
1142
1143    case LOC_INDIRECT:
1144      printf_filtered (_("external global (indirect addressing), at address *("));
1145      deprecated_print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1146			     1, gdb_stdout);
1147      printf_filtered (")");
1148      if (section_is_overlay (section))
1149	{
1150	  load_addr = overlay_unmapped_address (load_addr, section);
1151	  printf_filtered (_(",\n -- loaded at "));
1152	  deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1153	  printf_filtered (_(" in overlay section %s"), section->name);
1154	}
1155      break;
1156
1157    case LOC_REGPARM:
1158      printf_filtered (_("an argument in register %s"),
1159			 gdbarch_register_name (current_gdbarch, val));
1160      break;
1161
1162    case LOC_REGPARM_ADDR:
1163      printf_filtered (_("address of an argument in register %s"),
1164		       gdbarch_register_name (current_gdbarch, val));
1165      break;
1166
1167    case LOC_ARG:
1168      printf_filtered (_("an argument at offset %ld"), val);
1169      break;
1170
1171    case LOC_LOCAL_ARG:
1172      printf_filtered (_("an argument at frame offset %ld"), val);
1173      break;
1174
1175    case LOC_LOCAL:
1176      printf_filtered (_("a local variable at frame offset %ld"), val);
1177      break;
1178
1179    case LOC_REF_ARG:
1180      printf_filtered (_("a reference argument at offset %ld"), val);
1181      break;
1182
1183    case LOC_BASEREG:
1184      printf_filtered (_("a variable at offset %ld from register %s"),
1185		       val, gdbarch_register_name (current_gdbarch, basereg));
1186      break;
1187
1188    case LOC_BASEREG_ARG:
1189      printf_filtered (_("an argument at offset %ld from register %s"),
1190		       val, gdbarch_register_name (current_gdbarch, basereg));
1191      break;
1192
1193    case LOC_TYPEDEF:
1194      printf_filtered (_("a typedef"));
1195      break;
1196
1197    case LOC_BLOCK:
1198      printf_filtered (_("a function at address "));
1199      load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1200      deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1201      if (section_is_overlay (section))
1202	{
1203	  load_addr = overlay_unmapped_address (load_addr, section);
1204	  printf_filtered (_(",\n -- loaded at "));
1205	  deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1206	  printf_filtered (_(" in overlay section %s"), section->name);
1207	}
1208      break;
1209
1210    case LOC_UNRESOLVED:
1211      {
1212	struct minimal_symbol *msym;
1213
1214	msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, NULL);
1215	if (msym == NULL)
1216	  printf_filtered ("unresolved");
1217	else
1218	  {
1219	    section = SYMBOL_BFD_SECTION (msym);
1220	    printf_filtered (_("static storage at address "));
1221	    load_addr = SYMBOL_VALUE_ADDRESS (msym);
1222	    deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1223	    if (section_is_overlay (section))
1224	      {
1225		load_addr = overlay_unmapped_address (load_addr, section);
1226		printf_filtered (_(",\n -- loaded at "));
1227		deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
1228		printf_filtered (_(" in overlay section %s"), section->name);
1229	      }
1230	  }
1231      }
1232      break;
1233
1234    case LOC_HP_THREAD_LOCAL_STATIC:
1235      printf_filtered (_("\
1236a thread-local variable at offset %ld from the thread base register %s"),
1237		       val, gdbarch_register_name (current_gdbarch, basereg));
1238      break;
1239
1240    case LOC_OPTIMIZED_OUT:
1241      printf_filtered (_("optimized out"));
1242      break;
1243
1244    default:
1245      printf_filtered (_("of unknown (botched) type"));
1246      break;
1247    }
1248  printf_filtered (".\n");
1249}
1250
1251
1252static void
1253x_command (char *exp, int from_tty)
1254{
1255  struct expression *expr;
1256  struct format_data fmt;
1257  struct cleanup *old_chain;
1258  struct value *val;
1259
1260  fmt.format = last_format;
1261  fmt.size = last_size;
1262  fmt.count = 1;
1263
1264  if (exp && *exp == '/')
1265    {
1266      exp++;
1267      fmt = decode_format (&exp, last_format, last_size);
1268    }
1269
1270  /* If we have an expression, evaluate it and use it as the address.  */
1271
1272  if (exp != 0 && *exp != 0)
1273    {
1274      expr = parse_expression (exp);
1275      /* Cause expression not to be there any more if this command is
1276         repeated with Newline.  But don't clobber a user-defined
1277         command's definition.  */
1278      if (from_tty)
1279	*exp = 0;
1280      old_chain = make_cleanup (free_current_contents, &expr);
1281      val = evaluate_expression (expr);
1282      if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
1283	val = value_ind (val);
1284      /* In rvalue contexts, such as this, functions are coerced into
1285         pointers to functions.  This makes "x/i main" work.  */
1286      if (/* last_format == 'i'  && */
1287	  TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1288	   && VALUE_LVAL (val) == lval_memory)
1289	next_address = VALUE_ADDRESS (val);
1290      else
1291	next_address = value_as_address (val);
1292      do_cleanups (old_chain);
1293    }
1294
1295  do_examine (fmt, next_address);
1296
1297  /* If the examine succeeds, we remember its size and format for next
1298     time.  */
1299  last_size = fmt.size;
1300  last_format = fmt.format;
1301
1302  /* Set a couple of internal variables if appropriate. */
1303  if (last_examine_value)
1304    {
1305      /* Make last address examined available to the user as $_.  Use
1306         the correct pointer type.  */
1307      struct type *pointer_type
1308	= lookup_pointer_type (value_type (last_examine_value));
1309      set_internalvar (lookup_internalvar ("_"),
1310		       value_from_pointer (pointer_type,
1311					   last_examine_address));
1312
1313      /* Make contents of last address examined available to the user
1314	 as $__.  If the last value has not been fetched from memory
1315	 then don't fetch it now; instead mark it by voiding the $__
1316	 variable.  */
1317      if (value_lazy (last_examine_value))
1318	set_internalvar (lookup_internalvar ("__"),
1319			 allocate_value (builtin_type_void));
1320      else
1321	set_internalvar (lookup_internalvar ("__"), last_examine_value);
1322    }
1323}
1324
1325
1326/* Add an expression to the auto-display chain.
1327   Specify the expression.  */
1328
1329static void
1330display_command (char *exp, int from_tty)
1331{
1332  struct format_data fmt;
1333  struct expression *expr;
1334  struct display *new;
1335  int display_it = 1;
1336
1337#if defined(TUI)
1338  /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1339     `tui_version'.  */
1340  if (tui_active && exp != NULL && *exp == '$')
1341    display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
1342#endif
1343
1344  if (display_it)
1345    {
1346      if (exp == 0)
1347	{
1348	  do_displays ();
1349	  return;
1350	}
1351
1352      if (*exp == '/')
1353	{
1354	  exp++;
1355	  fmt = decode_format (&exp, 0, 0);
1356	  if (fmt.size && fmt.format == 0)
1357	    fmt.format = 'x';
1358	  if (fmt.format == 'i' || fmt.format == 's')
1359	    fmt.size = 'b';
1360	}
1361      else
1362	{
1363	  fmt.format = 0;
1364	  fmt.size = 0;
1365	  fmt.count = 0;
1366	}
1367
1368      innermost_block = 0;
1369      expr = parse_expression (exp);
1370
1371      new = (struct display *) xmalloc (sizeof (struct display));
1372
1373      new->exp = expr;
1374      new->block = innermost_block;
1375      new->next = display_chain;
1376      new->number = ++display_number;
1377      new->format = fmt;
1378      new->enabled_p = 1;
1379      display_chain = new;
1380
1381      if (from_tty && target_has_execution)
1382	do_one_display (new);
1383
1384      dont_repeat ();
1385    }
1386}
1387
1388static void
1389free_display (struct display *d)
1390{
1391  xfree (d->exp);
1392  xfree (d);
1393}
1394
1395/* Clear out the display_chain.  Done when new symtabs are loaded,
1396   since this invalidates the types stored in many expressions.  */
1397
1398void
1399clear_displays (void)
1400{
1401  struct display *d;
1402
1403  while ((d = display_chain) != NULL)
1404    {
1405      xfree (d->exp);
1406      display_chain = d->next;
1407      xfree (d);
1408    }
1409}
1410
1411/* Delete the auto-display number NUM.  */
1412
1413static void
1414delete_display (int num)
1415{
1416  struct display *d1, *d;
1417
1418  if (!display_chain)
1419    error (_("No display number %d."), num);
1420
1421  if (display_chain->number == num)
1422    {
1423      d1 = display_chain;
1424      display_chain = d1->next;
1425      free_display (d1);
1426    }
1427  else
1428    for (d = display_chain;; d = d->next)
1429      {
1430	if (d->next == 0)
1431	  error (_("No display number %d."), num);
1432	if (d->next->number == num)
1433	  {
1434	    d1 = d->next;
1435	    d->next = d1->next;
1436	    free_display (d1);
1437	    break;
1438	  }
1439      }
1440}
1441
1442/* Delete some values from the auto-display chain.
1443   Specify the element numbers.  */
1444
1445static void
1446undisplay_command (char *args, int from_tty)
1447{
1448  char *p = args;
1449  char *p1;
1450  int num;
1451
1452  if (args == 0)
1453    {
1454      if (query ("Delete all auto-display expressions? "))
1455	clear_displays ();
1456      dont_repeat ();
1457      return;
1458    }
1459
1460  while (*p)
1461    {
1462      p1 = p;
1463      while (*p1 >= '0' && *p1 <= '9')
1464	p1++;
1465      if (*p1 && *p1 != ' ' && *p1 != '\t')
1466	error (_("Arguments must be display numbers."));
1467
1468      num = atoi (p);
1469
1470      delete_display (num);
1471
1472      p = p1;
1473      while (*p == ' ' || *p == '\t')
1474	p++;
1475    }
1476  dont_repeat ();
1477}
1478
1479/* Display a single auto-display.
1480   Do nothing if the display cannot be printed in the current context,
1481   or if the display is disabled. */
1482
1483static void
1484do_one_display (struct display *d)
1485{
1486  int within_current_scope;
1487
1488  if (d->enabled_p == 0)
1489    return;
1490
1491  if (d->block)
1492    within_current_scope = contained_in (get_selected_block (0), d->block);
1493  else
1494    within_current_scope = 1;
1495  if (!within_current_scope)
1496    return;
1497
1498  current_display_number = d->number;
1499
1500  annotate_display_begin ();
1501  printf_filtered ("%d", d->number);
1502  annotate_display_number_end ();
1503  printf_filtered (": ");
1504  if (d->format.size)
1505    {
1506      CORE_ADDR addr;
1507      struct value *val;
1508
1509      annotate_display_format ();
1510
1511      printf_filtered ("x/");
1512      if (d->format.count != 1)
1513	printf_filtered ("%d", d->format.count);
1514      printf_filtered ("%c", d->format.format);
1515      if (d->format.format != 'i' && d->format.format != 's')
1516	printf_filtered ("%c", d->format.size);
1517      printf_filtered (" ");
1518
1519      annotate_display_expression ();
1520
1521      print_expression (d->exp, gdb_stdout);
1522      annotate_display_expression_end ();
1523
1524      if (d->format.count != 1 || d->format.format == 'i')
1525	printf_filtered ("\n");
1526      else
1527	printf_filtered ("  ");
1528
1529      val = evaluate_expression (d->exp);
1530      addr = value_as_address (val);
1531      if (d->format.format == 'i')
1532	addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
1533
1534      annotate_display_value ();
1535
1536      do_examine (d->format, addr);
1537    }
1538  else
1539    {
1540      annotate_display_format ();
1541
1542      if (d->format.format)
1543	printf_filtered ("/%c ", d->format.format);
1544
1545      annotate_display_expression ();
1546
1547      print_expression (d->exp, gdb_stdout);
1548      annotate_display_expression_end ();
1549
1550      printf_filtered (" = ");
1551
1552      annotate_display_expression ();
1553
1554      print_formatted (evaluate_expression (d->exp),
1555		       d->format.format, d->format.size, gdb_stdout);
1556      printf_filtered ("\n");
1557    }
1558
1559  annotate_display_end ();
1560
1561  gdb_flush (gdb_stdout);
1562  current_display_number = -1;
1563}
1564
1565/* Display all of the values on the auto-display chain which can be
1566   evaluated in the current scope.  */
1567
1568void
1569do_displays (void)
1570{
1571  struct display *d;
1572
1573  for (d = display_chain; d; d = d->next)
1574    do_one_display (d);
1575}
1576
1577/* Delete the auto-display which we were in the process of displaying.
1578   This is done when there is an error or a signal.  */
1579
1580void
1581disable_display (int num)
1582{
1583  struct display *d;
1584
1585  for (d = display_chain; d; d = d->next)
1586    if (d->number == num)
1587      {
1588	d->enabled_p = 0;
1589	return;
1590      }
1591  printf_unfiltered (_("No display number %d.\n"), num);
1592}
1593
1594void
1595disable_current_display (void)
1596{
1597  if (current_display_number >= 0)
1598    {
1599      disable_display (current_display_number);
1600      fprintf_unfiltered (gdb_stderr, _("\
1601Disabling display %d to avoid infinite recursion.\n"),
1602			  current_display_number);
1603    }
1604  current_display_number = -1;
1605}
1606
1607static void
1608display_info (char *ignore, int from_tty)
1609{
1610  struct display *d;
1611
1612  if (!display_chain)
1613    printf_unfiltered (_("There are no auto-display expressions now.\n"));
1614  else
1615    printf_filtered (_("Auto-display expressions now in effect:\n\
1616Num Enb Expression\n"));
1617
1618  for (d = display_chain; d; d = d->next)
1619    {
1620      printf_filtered ("%d:   %c  ", d->number, "ny"[(int) d->enabled_p]);
1621      if (d->format.size)
1622	printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1623			 d->format.format);
1624      else if (d->format.format)
1625	printf_filtered ("/%c ", d->format.format);
1626      print_expression (d->exp, gdb_stdout);
1627      if (d->block && !contained_in (get_selected_block (0), d->block))
1628	printf_filtered (_(" (cannot be evaluated in the current context)"));
1629      printf_filtered ("\n");
1630      gdb_flush (gdb_stdout);
1631    }
1632}
1633
1634static void
1635enable_display (char *args, int from_tty)
1636{
1637  char *p = args;
1638  char *p1;
1639  int num;
1640  struct display *d;
1641
1642  if (p == 0)
1643    {
1644      for (d = display_chain; d; d = d->next)
1645	d->enabled_p = 1;
1646    }
1647  else
1648    while (*p)
1649      {
1650	p1 = p;
1651	while (*p1 >= '0' && *p1 <= '9')
1652	  p1++;
1653	if (*p1 && *p1 != ' ' && *p1 != '\t')
1654	  error (_("Arguments must be display numbers."));
1655
1656	num = atoi (p);
1657
1658	for (d = display_chain; d; d = d->next)
1659	  if (d->number == num)
1660	    {
1661	      d->enabled_p = 1;
1662	      goto win;
1663	    }
1664	printf_unfiltered (_("No display number %d.\n"), num);
1665      win:
1666	p = p1;
1667	while (*p == ' ' || *p == '\t')
1668	  p++;
1669      }
1670}
1671
1672static void
1673disable_display_command (char *args, int from_tty)
1674{
1675  char *p = args;
1676  char *p1;
1677  struct display *d;
1678
1679  if (p == 0)
1680    {
1681      for (d = display_chain; d; d = d->next)
1682	d->enabled_p = 0;
1683    }
1684  else
1685    while (*p)
1686      {
1687	p1 = p;
1688	while (*p1 >= '0' && *p1 <= '9')
1689	  p1++;
1690	if (*p1 && *p1 != ' ' && *p1 != '\t')
1691	  error (_("Arguments must be display numbers."));
1692
1693	disable_display (atoi (p));
1694
1695	p = p1;
1696	while (*p == ' ' || *p == '\t')
1697	  p++;
1698      }
1699}
1700
1701
1702/* Print the value in stack frame FRAME of a variable specified by a
1703   struct symbol.  */
1704
1705void
1706print_variable_value (struct symbol *var, struct frame_info *frame,
1707		      struct ui_file *stream)
1708{
1709  struct value *val = read_var_value (var, frame);
1710
1711  value_print (val, stream, 0, Val_pretty_default);
1712}
1713
1714static void
1715printf_command (char *arg, int from_tty)
1716{
1717  char *f = NULL;
1718  char *s = arg;
1719  char *string = NULL;
1720  struct value **val_args;
1721  char *substrings;
1722  char *current_substring;
1723  int nargs = 0;
1724  int allocated_args = 20;
1725  struct cleanup *old_cleanups;
1726
1727  val_args = xmalloc (allocated_args * sizeof (struct value *));
1728  old_cleanups = make_cleanup (free_current_contents, &val_args);
1729
1730  if (s == 0)
1731    error_no_arg (_("format-control string and values to print"));
1732
1733  /* Skip white space before format string */
1734  while (*s == ' ' || *s == '\t')
1735    s++;
1736
1737  /* A format string should follow, enveloped in double quotes.  */
1738  if (*s++ != '"')
1739    error (_("Bad format string, missing '\"'."));
1740
1741  /* Parse the format-control string and copy it into the string STRING,
1742     processing some kinds of escape sequence.  */
1743
1744  f = string = (char *) alloca (strlen (s) + 1);
1745
1746  while (*s != '"')
1747    {
1748      int c = *s++;
1749      switch (c)
1750	{
1751	case '\0':
1752	  error (_("Bad format string, non-terminated '\"'."));
1753
1754	case '\\':
1755	  switch (c = *s++)
1756	    {
1757	    case '\\':
1758	      *f++ = '\\';
1759	      break;
1760	    case 'a':
1761	      *f++ = '\a';
1762	      break;
1763	    case 'b':
1764	      *f++ = '\b';
1765	      break;
1766	    case 'f':
1767	      *f++ = '\f';
1768	      break;
1769	    case 'n':
1770	      *f++ = '\n';
1771	      break;
1772	    case 'r':
1773	      *f++ = '\r';
1774	      break;
1775	    case 't':
1776	      *f++ = '\t';
1777	      break;
1778	    case 'v':
1779	      *f++ = '\v';
1780	      break;
1781	    case '"':
1782	      *f++ = '"';
1783	      break;
1784	    default:
1785	      /* ??? TODO: handle other escape sequences */
1786	      error (_("Unrecognized escape character \\%c in format string."),
1787		     c);
1788	    }
1789	  break;
1790
1791	default:
1792	  *f++ = c;
1793	}
1794    }
1795
1796  /* Skip over " and following space and comma.  */
1797  s++;
1798  *f++ = '\0';
1799  while (*s == ' ' || *s == '\t')
1800    s++;
1801
1802  if (*s != ',' && *s != 0)
1803    error (_("Invalid argument syntax"));
1804
1805  if (*s == ',')
1806    s++;
1807  while (*s == ' ' || *s == '\t')
1808    s++;
1809
1810  /* Need extra space for the '\0's.  Doubling the size is sufficient.  */
1811  substrings = alloca (strlen (string) * 2);
1812  current_substring = substrings;
1813
1814  {
1815    /* Now scan the string for %-specs and see what kinds of args they want.
1816       argclass[I] classifies the %-specs so we can give printf_filtered
1817       something of the right size.  */
1818
1819    enum argclass
1820      {
1821	int_arg, long_arg, long_long_arg, ptr_arg, string_arg,
1822	double_arg, long_double_arg
1823      };
1824    enum argclass *argclass;
1825    enum argclass this_argclass;
1826    char *last_arg;
1827    int nargs_wanted;
1828    int i;
1829
1830    argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
1831    nargs_wanted = 0;
1832    f = string;
1833    last_arg = string;
1834    while (*f)
1835      if (*f++ == '%')
1836	{
1837	  int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
1838	  int seen_space = 0, seen_plus = 0;
1839	  int seen_big_l = 0, seen_h = 0;
1840	  int bad = 0;
1841
1842	  /* Check the validity of the format specifier, and work
1843	     out what argument it expects.  We only accept C89
1844	     format strings, with the exception of long long (which
1845	     we autoconf for).  */
1846
1847	  /* Skip over "%%".  */
1848	  if (*f == '%')
1849	    {
1850	      f++;
1851	      continue;
1852	    }
1853
1854	  /* The first part of a format specifier is a set of flag
1855	     characters.  */
1856	  while (strchr ("0-+ #", *f))
1857	    {
1858	      if (*f == '#')
1859		seen_hash = 1;
1860	      else if (*f == '0')
1861		seen_zero = 1;
1862	      else if (*f == ' ')
1863		seen_space = 1;
1864	      else if (*f == '+')
1865		seen_plus = 1;
1866	      f++;
1867	    }
1868
1869	  /* The next part of a format specifier is a width.  */
1870	  while (strchr ("0123456789", *f))
1871	    f++;
1872
1873	  /* The next part of a format specifier is a precision.  */
1874	  if (*f == '.')
1875	    {
1876	      seen_prec = 1;
1877	      f++;
1878	      while (strchr ("0123456789", *f))
1879		f++;
1880	    }
1881
1882	  /* The next part of a format specifier is a length modifier.  */
1883	  if (*f == 'h')
1884	    {
1885	      seen_h = 1;
1886	      f++;
1887	    }
1888	  else if (*f == 'l')
1889	    {
1890	      f++;
1891	      lcount++;
1892	      if (*f == 'l')
1893		{
1894		  f++;
1895		  lcount++;
1896		}
1897	    }
1898	  else if (*f == 'L')
1899	    {
1900	      seen_big_l = 1;
1901	      f++;
1902	    }
1903
1904	  switch (*f)
1905	    {
1906	    case 'u':
1907	      if (seen_hash)
1908		bad = 1;
1909	      /* FALLTHROUGH */
1910
1911	    case 'o':
1912	    case 'x':
1913	    case 'X':
1914	      if (seen_space || seen_plus)
1915		bad = 1;
1916	      /* FALLTHROUGH */
1917
1918	    case 'd':
1919	    case 'i':
1920	      if (lcount == 0)
1921		this_argclass = int_arg;
1922	      else if (lcount == 1)
1923		this_argclass = long_arg;
1924	      else
1925		this_argclass = long_long_arg;
1926
1927	      if (seen_big_l)
1928		bad = 1;
1929	      break;
1930
1931	    case 'c':
1932	      this_argclass = int_arg;
1933	      if (lcount || seen_h || seen_big_l)
1934		bad = 1;
1935	      if (seen_prec || seen_zero || seen_space || seen_plus)
1936		bad = 1;
1937	      break;
1938
1939	    case 'p':
1940	      this_argclass = ptr_arg;
1941	      if (lcount || seen_h || seen_big_l)
1942		bad = 1;
1943	      if (seen_prec || seen_zero || seen_space || seen_plus)
1944		bad = 1;
1945	      break;
1946
1947	    case 's':
1948	      this_argclass = string_arg;
1949	      if (lcount || seen_h || seen_big_l)
1950		bad = 1;
1951	      if (seen_zero || seen_space || seen_plus)
1952		bad = 1;
1953	      break;
1954
1955	    case 'e':
1956	    case 'f':
1957	    case 'g':
1958	    case 'E':
1959	    case 'G':
1960	      if (seen_big_l)
1961		this_argclass = long_double_arg;
1962	      else
1963		this_argclass = double_arg;
1964
1965	      if (lcount || seen_h)
1966		bad = 1;
1967	      break;
1968
1969	    case '*':
1970	      error (_("`*' not supported for precision or width in printf"));
1971
1972	    case 'n':
1973	      error (_("Format specifier `n' not supported in printf"));
1974
1975	    case '\0':
1976	      error (_("Incomplete format specifier at end of format string"));
1977
1978	    default:
1979	      error (_("Unrecognized format specifier '%c' in printf"), *f);
1980	    }
1981
1982	  if (bad)
1983	    error (_("Inappropriate modifiers to format specifier '%c' in printf"),
1984		   *f);
1985
1986	  f++;
1987	  strncpy (current_substring, last_arg, f - last_arg);
1988	  current_substring += f - last_arg;
1989	  *current_substring++ = '\0';
1990	  last_arg = f;
1991	  argclass[nargs_wanted++] = this_argclass;
1992	}
1993
1994    /* Now, parse all arguments and evaluate them.
1995       Store the VALUEs in VAL_ARGS.  */
1996
1997    while (*s != '\0')
1998      {
1999	char *s1;
2000	if (nargs == allocated_args)
2001	  val_args = (struct value **) xrealloc ((char *) val_args,
2002						 (allocated_args *= 2)
2003						 * sizeof (struct value *));
2004	s1 = s;
2005	val_args[nargs] = parse_to_comma_and_eval (&s1);
2006
2007	/* If format string wants a float, unchecked-convert the value to
2008	   floating point of the same size */
2009
2010	if (argclass[nargs] == double_arg)
2011	  {
2012	    struct type *type = value_type (val_args[nargs]);
2013	    if (TYPE_LENGTH (type) == sizeof (float))
2014	      deprecated_set_value_type (val_args[nargs], builtin_type_float);
2015	    if (TYPE_LENGTH (type) == sizeof (double))
2016	      deprecated_set_value_type (val_args[nargs], builtin_type_double);
2017	  }
2018	nargs++;
2019	s = s1;
2020	if (*s == ',')
2021	  s++;
2022      }
2023
2024    if (nargs != nargs_wanted)
2025      error (_("Wrong number of arguments for specified format-string"));
2026
2027    /* Now actually print them.  */
2028    current_substring = substrings;
2029    for (i = 0; i < nargs; i++)
2030      {
2031	switch (argclass[i])
2032	  {
2033	  case string_arg:
2034	    {
2035	      gdb_byte *str;
2036	      CORE_ADDR tem;
2037	      int j;
2038	      tem = value_as_address (val_args[i]);
2039
2040	      /* This is a %s argument.  Find the length of the string.  */
2041	      for (j = 0;; j++)
2042		{
2043		  gdb_byte c;
2044		  QUIT;
2045		  read_memory (tem + j, &c, 1);
2046		  if (c == 0)
2047		    break;
2048		}
2049
2050	      /* Copy the string contents into a string inside GDB.  */
2051	      str = (gdb_byte *) alloca (j + 1);
2052	      if (j != 0)
2053		read_memory (tem, str, j);
2054	      str[j] = 0;
2055
2056	      printf_filtered (current_substring, (char *) str);
2057	    }
2058	    break;
2059	  case double_arg:
2060	    {
2061	      double val = value_as_double (val_args[i]);
2062	      printf_filtered (current_substring, val);
2063	      break;
2064	    }
2065	  case long_double_arg:
2066#ifdef HAVE_LONG_DOUBLE
2067	    {
2068	      long double val = value_as_double (val_args[i]);
2069	      printf_filtered (current_substring, val);
2070	      break;
2071	    }
2072#else
2073	    error (_("long double not supported in printf"));
2074#endif
2075	  case long_long_arg:
2076#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2077	    {
2078	      long long val = value_as_long (val_args[i]);
2079	      printf_filtered (current_substring, val);
2080	      break;
2081	    }
2082#else
2083	    error (_("long long not supported in printf"));
2084#endif
2085	  case int_arg:
2086	    {
2087	      int val = value_as_long (val_args[i]);
2088	      printf_filtered (current_substring, val);
2089	      break;
2090	    }
2091	  case long_arg:
2092	    {
2093	      long val = value_as_long (val_args[i]);
2094	      printf_filtered (current_substring, val);
2095	      break;
2096	    }
2097	  case ptr_arg:
2098	    {
2099	      /* We avoid the host's %p because pointers are too
2100		 likely to be the wrong size.  The only interesting
2101		 modifier for %p is a width; extract that, and then
2102		 handle %p as glibc would: %#x or a literal "(nil)".  */
2103
2104	      char *p, *fmt, *fmt_p;
2105#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2106	      long long val = value_as_long (val_args[i]);
2107#else
2108	      long val = value_as_long (val_args[i]);
2109#endif
2110
2111	      fmt = alloca (strlen (current_substring) + 5);
2112
2113	      /* Copy up to the leading %.  */
2114	      p = current_substring;
2115	      fmt_p = fmt;
2116	      while (*p)
2117		{
2118		  int is_percent = (*p == '%');
2119		  *fmt_p++ = *p++;
2120		  if (is_percent)
2121		    {
2122		      if (*p == '%')
2123			*fmt_p++ = *p++;
2124		      else
2125			break;
2126		    }
2127		}
2128
2129	      if (val != 0)
2130		*fmt_p++ = '#';
2131
2132	      /* Copy any width.  */
2133	      while (*p >= '0' && *p < '9')
2134		*fmt_p++ = *p++;
2135
2136	      gdb_assert (*p == 'p' && *(p + 1) == '\0');
2137	      if (val != 0)
2138		{
2139#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2140		  *fmt_p++ = 'l';
2141#endif
2142		  *fmt_p++ = 'l';
2143		  *fmt_p++ = 'x';
2144		  *fmt_p++ = '\0';
2145		  printf_filtered (fmt, val);
2146		}
2147	      else
2148		{
2149		  *fmt_p++ = 's';
2150		  *fmt_p++ = '\0';
2151		  printf_filtered (fmt, "(nil)");
2152		}
2153
2154	      break;
2155	    }
2156	  default:
2157	    internal_error (__FILE__, __LINE__,
2158			    _("failed internal consistency check"));
2159	  }
2160	/* Skip to the next substring.  */
2161	current_substring += strlen (current_substring) + 1;
2162      }
2163    /* Print the portion of the format string after the last argument.  */
2164    puts_filtered (last_arg);
2165  }
2166  do_cleanups (old_cleanups);
2167}
2168
2169void
2170_initialize_printcmd (void)
2171{
2172  struct cmd_list_element *c;
2173
2174  current_display_number = -1;
2175
2176  add_info ("address", address_info,
2177	    _("Describe where symbol SYM is stored."));
2178
2179  add_info ("symbol", sym_info, _("\
2180Describe what symbol is at location ADDR.\n\
2181Only for symbols with fixed locations (global or static scope)."));
2182
2183  add_com ("x", class_vars, x_command, _("\
2184Examine memory: x/FMT ADDRESS.\n\
2185ADDRESS is an expression for the memory address to examine.\n\
2186FMT is a repeat count followed by a format letter and a size letter.\n\
2187Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2188  t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2189Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2190The specified number of objects of the specified size are printed\n\
2191according to the format.\n\n\
2192Defaults for format and size letters are those previously used.\n\
2193Default count is 1.  Default address is following last thing printed\n\
2194with this command or \"print\"."));
2195
2196#if 0
2197  add_com ("whereis", class_vars, whereis_command,
2198	   _("Print line number and file of definition of variable."));
2199#endif
2200
2201  add_info ("display", display_info, _("\
2202Expressions to display when program stops, with code numbers."));
2203
2204  add_cmd ("undisplay", class_vars, undisplay_command, _("\
2205Cancel some expressions to be displayed when program stops.\n\
2206Arguments are the code numbers of the expressions to stop displaying.\n\
2207No argument means cancel all automatic-display expressions.\n\
2208\"delete display\" has the same effect as this command.\n\
2209Do \"info display\" to see current list of code numbers."),
2210	   &cmdlist);
2211
2212  add_com ("display", class_vars, display_command, _("\
2213Print value of expression EXP each time the program stops.\n\
2214/FMT may be used before EXP as in the \"print\" command.\n\
2215/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2216as in the \"x\" command, and then EXP is used to get the address to examine\n\
2217and examining is done as in the \"x\" command.\n\n\
2218With no argument, display all currently requested auto-display expressions.\n\
2219Use \"undisplay\" to cancel display requests previously made."));
2220
2221  add_cmd ("display", class_vars, enable_display, _("\
2222Enable some expressions to be displayed when program stops.\n\
2223Arguments are the code numbers of the expressions to resume displaying.\n\
2224No argument means enable all automatic-display expressions.\n\
2225Do \"info display\" to see current list of code numbers."), &enablelist);
2226
2227  add_cmd ("display", class_vars, disable_display_command, _("\
2228Disable some expressions to be displayed when program stops.\n\
2229Arguments are the code numbers of the expressions to stop displaying.\n\
2230No argument means disable all automatic-display expressions.\n\
2231Do \"info display\" to see current list of code numbers."), &disablelist);
2232
2233  add_cmd ("display", class_vars, undisplay_command, _("\
2234Cancel some expressions to be displayed when program stops.\n\
2235Arguments are the code numbers of the expressions to stop displaying.\n\
2236No argument means cancel all automatic-display expressions.\n\
2237Do \"info display\" to see current list of code numbers."), &deletelist);
2238
2239  add_com ("printf", class_vars, printf_command, _("\
2240printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2241This is useful for formatted output in user-defined commands."));
2242
2243  add_com ("output", class_vars, output_command, _("\
2244Like \"print\" but don't put in value history and don't print newline.\n\
2245This is useful in user-defined commands."));
2246
2247  add_prefix_cmd ("set", class_vars, set_command, _("\
2248Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2249syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2250example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2251with $), a register (a few standard names starting with $), or an actual\n\
2252variable in the program being debugged.  EXP is any valid expression.\n\
2253Use \"set variable\" for variables with names identical to set subcommands.\n\
2254\n\
2255With a subcommand, this command modifies parts of the gdb environment.\n\
2256You can see these environment settings with the \"show\" command."),
2257		  &setlist, "set ", 1, &cmdlist);
2258  if (dbx_commands)
2259    add_com ("assign", class_vars, set_command, _("\
2260Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2261syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2262example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2263with $), a register (a few standard names starting with $), or an actual\n\
2264variable in the program being debugged.  EXP is any valid expression.\n\
2265Use \"set variable\" for variables with names identical to set subcommands.\n\
2266\nWith a subcommand, this command modifies parts of the gdb environment.\n\
2267You can see these environment settings with the \"show\" command."));
2268
2269  /* "call" is the same as "set", but handy for dbx users to call fns. */
2270  c = add_com ("call", class_vars, call_command, _("\
2271Call a function in the program.\n\
2272The argument is the function name and arguments, in the notation of the\n\
2273current working language.  The result is printed and saved in the value\n\
2274history, if it is not void."));
2275  set_cmd_completer (c, location_completer);
2276
2277  add_cmd ("variable", class_vars, set_command, _("\
2278Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2279syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2280example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2281with $), a register (a few standard names starting with $), or an actual\n\
2282variable in the program being debugged.  EXP is any valid expression.\n\
2283This may usually be abbreviated to simply \"set\"."),
2284	   &setlist);
2285
2286  c = add_com ("print", class_vars, print_command, _("\
2287Print value of expression EXP.\n\
2288Variables accessible are those of the lexical environment of the selected\n\
2289stack frame, plus all those whose scope is global or an entire file.\n\
2290\n\
2291$NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
2292$$NUM refers to NUM'th value back from the last one.\n\
2293Names starting with $ refer to registers (with the values they would have\n\
2294if the program were to return to the stack frame now selected, restoring\n\
2295all registers saved by frames farther in) or else to debugger\n\
2296\"convenience\" variables (any such name not a known register).\n\
2297Use assignment expressions to give values to convenience variables.\n\
2298\n\
2299{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2300@ is a binary operator for treating consecutive data objects\n\
2301anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
2302element is FOO, whose second element is stored in the space following\n\
2303where FOO is stored, etc.  FOO must be an expression whose value\n\
2304resides in memory.\n\
2305\n\
2306EXP may be preceded with /FMT, where FMT is a format letter\n\
2307but no count or size letter (see \"x\" command)."));
2308  set_cmd_completer (c, location_completer);
2309  add_com_alias ("p", "print", class_vars, 1);
2310
2311  c = add_com ("inspect", class_vars, inspect_command, _("\
2312Same as \"print\" command, except that if you are running in the epoch\n\
2313environment, the value is printed in its own window."));
2314  set_cmd_completer (c, location_completer);
2315
2316  add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2317			    &max_symbolic_offset, _("\
2318Set the largest offset that will be printed in <symbol+1234> form."), _("\
2319Show the largest offset that will be printed in <symbol+1234> form."), NULL,
2320			    NULL,
2321			    show_max_symbolic_offset,
2322			    &setprintlist, &showprintlist);
2323  add_setshow_boolean_cmd ("symbol-filename", no_class,
2324			   &print_symbol_filename, _("\
2325Set printing of source filename and line number with <symbol>."), _("\
2326Show printing of source filename and line number with <symbol>."), NULL,
2327			   NULL,
2328			   show_print_symbol_filename,
2329			   &setprintlist, &showprintlist);
2330
2331  /* For examine/instruction a single byte quantity is specified as
2332     the data.  This avoids problems with value_at_lazy() requiring a
2333     valid data type (and rejecting VOID). */
2334  examine_i_type = init_type (TYPE_CODE_INT, 1, 0, "examine_i_type", NULL);
2335
2336  examine_b_type = init_type (TYPE_CODE_INT, 1, 0, "examine_b_type", NULL);
2337  examine_h_type = init_type (TYPE_CODE_INT, 2, 0, "examine_h_type", NULL);
2338  examine_w_type = init_type (TYPE_CODE_INT, 4, 0, "examine_w_type", NULL);
2339  examine_g_type = init_type (TYPE_CODE_INT, 8, 0, "examine_g_type", NULL);
2340
2341}
2342