home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gdb-4.12-src.lha / GNU / src / amiga / gdb-4.12 / gdb / printcmd.c < prev    next >
C/C++ Source or Header  |  1994-02-03  |  59KB  |  2,159 lines
  1. /* Print values for GNU debugger GDB.
  2.    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994
  3.              Free Software Foundation, Inc.
  4.  
  5. This file is part of GDB.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include "defs.h"
  22. #include <string.h>
  23. #include <varargs.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.  
  37. extern int asm_demangle;    /* Whether to demangle syms in asm printouts */
  38. extern int addressprint;    /* Whether to print hex addresses in HLL " */
  39.  
  40. struct format_data
  41. {
  42.   int count;
  43.   char format;
  44.   char size;
  45. };
  46.  
  47. /* Last specified output format.  */
  48.  
  49. static char last_format = 'x';
  50.  
  51. /* Last specified examination size.  'b', 'h', 'w' or `q'.  */
  52.  
  53. static char last_size = 'w';
  54.  
  55. /* Default address to examine next.  */
  56.  
  57. static CORE_ADDR next_address;
  58.  
  59. /* Last address examined.  */
  60.  
  61. static CORE_ADDR last_examine_address;
  62.  
  63. /* Contents of last address examined.
  64.    This is not valid past the end of the `x' command!  */
  65.  
  66. static value last_examine_value;
  67.  
  68. /* Largest offset between a symbolic value and an address, that will be
  69.    printed as `0x1234 <symbol+offset>'.  */
  70.  
  71. static unsigned int max_symbolic_offset = UINT_MAX;
  72.  
  73. /* Append the source filename and linenumber of the symbol when
  74.    printing a symbolic value as `<symbol at filename:linenum>' if set.  */
  75. static int print_symbol_filename = 0;
  76.  
  77. /* Switch for quick display of symbolic addresses -- only uses minsyms,
  78.    not full search of symtabs.  */
  79.  
  80. int fast_symbolic_addr = 1;
  81.  
  82. /* Number of auto-display expression currently being displayed.
  83.    So that we can disable it if we get an error or a signal within it.
  84.    -1 when not doing one.  */
  85.  
  86. int current_display_number;
  87.  
  88. /* Flag to low-level print routines that this value is being printed
  89.    in an epoch window.  We'd like to pass this as a parameter, but
  90.    every routine would need to take it.  Perhaps we can encapsulate
  91.    this in the I/O stream once we have GNU stdio. */
  92.  
  93. int inspect_it = 0;
  94.  
  95. struct display
  96. {
  97.   /* Chain link to next auto-display item.  */
  98.   struct display *next;
  99.   /* Expression to be evaluated and displayed.  */
  100.   struct expression *exp;
  101.   /* Item number of this auto-display item.  */
  102.   int number;
  103.   /* Display format specified.  */
  104.   struct format_data format;
  105.   /* Innermost block required by this expression when evaluated */
  106.   struct block *block;
  107.   /* Status of this display (enabled or disabled) */
  108.   enum enable status;
  109. };
  110.  
  111. /* Chain of expressions whose values should be displayed
  112.    automatically each time the program stops.  */
  113.  
  114. static struct display *display_chain;
  115.  
  116. static int display_number;
  117.  
  118. /* Prototypes for local functions */
  119.  
  120. static void
  121. delete_display PARAMS ((int));
  122.  
  123. static void
  124. enable_display PARAMS ((char *, int));
  125.  
  126. static void
  127. disable_display_command PARAMS ((char *, int));
  128.  
  129. static void
  130. disassemble_command PARAMS ((char *, int));
  131.  
  132. static void
  133. printf_command PARAMS ((char *, int));
  134.  
  135. static void
  136. print_frame_nameless_args PARAMS ((struct frame_info *, long, int, int,
  137.                    GDB_FILE *));
  138.  
  139. static void
  140. display_info PARAMS ((char *, int));
  141.  
  142. static void
  143. do_one_display PARAMS ((struct display *));
  144.  
  145. static void
  146. undisplay_command PARAMS ((char *, int));
  147.  
  148. static void
  149. free_display PARAMS ((struct display *));
  150.  
  151. static void
  152. display_command PARAMS ((char *, int));
  153.  
  154. static void
  155. x_command PARAMS ((char *, int));
  156.  
  157. static void
  158. address_info PARAMS ((char *, int));
  159.  
  160. static void
  161. set_command PARAMS ((char *, int));
  162.  
  163. static void
  164. output_command PARAMS ((char *, int));
  165.  
  166. static void
  167. call_command PARAMS ((char *, int));
  168.  
  169. static void
  170. inspect_command PARAMS ((char *, int));
  171.  
  172. static void
  173. print_command PARAMS ((char *, int));
  174.  
  175. static void
  176. print_command_1 PARAMS ((char *, int, int));
  177.  
  178. static void
  179. validate_format PARAMS ((struct format_data, char *));
  180.  
  181. static void
  182. do_examine PARAMS ((struct format_data, CORE_ADDR));
  183.  
  184. static void
  185. print_formatted PARAMS ((value, int, int));
  186.  
  187. static struct format_data
  188. decode_format PARAMS ((char **, int, int));
  189.  
  190.  
  191. /* Decode a format specification.  *STRING_PTR should point to it.
  192.    OFORMAT and OSIZE are used as defaults for the format and size
  193.    if none are given in the format specification.
  194.    If OSIZE is zero, then the size field of the returned value
  195.    should be set only if a size is explicitly specified by the
  196.    user.
  197.    The structure returned describes all the data
  198.    found in the specification.  In addition, *STRING_PTR is advanced
  199.    past the specification and past all whitespace following it.  */
  200.  
  201. static struct format_data
  202. decode_format (string_ptr, oformat, osize)
  203.      char **string_ptr;
  204.      int oformat;
  205.      int osize;
  206. {
  207.   struct format_data val;
  208.   register char *p = *string_ptr;
  209.  
  210.   val.format = '?';
  211.   val.size = '?';
  212.   val.count = 1;
  213.  
  214.   if (*p >= '0' && *p <= '9')
  215.     val.count = atoi (p);
  216.   while (*p >= '0' && *p <= '9') p++;
  217.  
  218.   /* Now process size or format letters that follow.  */
  219.  
  220.   while (1)
  221.     {
  222.       if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
  223.     val.size = *p++;
  224.       else if (*p >= 'a' && *p <= 'z')
  225.     val.format = *p++;
  226.       else
  227.     break;
  228.     }
  229.  
  230. #ifndef CC_HAS_LONG_LONG
  231.   /* Make sure 'g' size is not used on integer types.
  232.      Well, actually, we can handle hex.  */
  233.   if (val.size == 'g' && val.format != 'f' && val.format != 'x')
  234.     val.size = 'w';
  235. #endif
  236.  
  237.   while (*p == ' ' || *p == '\t') p++;
  238.   *string_ptr = p;
  239.  
  240.   /* Set defaults for format and size if not specified.  */
  241.   if (val.format == '?')
  242.     {
  243.       if (val.size == '?')
  244.     {
  245.       /* Neither has been specified.  */
  246.       val.format = oformat;
  247.       val.size = osize;
  248.     }
  249.       else
  250.     /* If a size is specified, any format makes a reasonable
  251.        default except 'i'.  */
  252.     val.format = oformat == 'i' ? 'x' : oformat;
  253.     }
  254.   else if (val.size == '?')
  255.     switch (val.format)
  256.       {
  257.       case 'a':
  258.       case 's':
  259.     /* Addresses must be words.  */
  260.     val.size = osize ? 'w' : osize;
  261.     break;
  262.       case 'f':
  263.     /* Floating point has to be word or giantword.  */
  264.     if (osize == 'w' || osize == 'g')
  265.       val.size = osize;
  266.     else
  267.       /* Default it to giantword if the last used size is not
  268.          appropriate.  */
  269.       val.size = osize ? 'g' : osize;
  270.     break;
  271.       case 'c':
  272.     /* Characters default to one byte.  */
  273.     val.size = osize ? 'b' : osize;
  274.     break;
  275.       default:
  276.     /* The default is the size most recently specified.  */
  277.     val.size = osize;
  278.       }
  279.  
  280.   return val;
  281. }
  282.  
  283. /* Print value VAL on gdb_stdout according to FORMAT, a letter or 0.
  284.    Do not end with a newline.
  285.    0 means print VAL according to its own type.
  286.    SIZE is the letter for the size of datum being printed.
  287.    This is used to pad hex numbers so they line up.  */
  288.  
  289. static void
  290. print_formatted (val, format, size)
  291.      register value val;
  292.      register int format;
  293.      int size;
  294. {
  295.   int len = TYPE_LENGTH (VALUE_TYPE (val));
  296.  
  297.   if (VALUE_LVAL (val) == lval_memory)
  298.     next_address = VALUE_ADDRESS (val) + len;
  299.  
  300.   switch (format)
  301.     {
  302.     case 's':
  303.       next_address = VALUE_ADDRESS (val)
  304.     + value_print (value_addr (val), gdb_stdout, format, Val_pretty_default);
  305.       break;
  306.  
  307.     case 'i':
  308.       /* The old comment says
  309.      "Force output out, print_insn not using _filtered".
  310.      I'm not completely sure what that means, I suspect most print_insn
  311.      now do use _filtered, so I guess it's obsolete.  */
  312.       /* We often wrap here if there are long symbolic names.  */
  313.       wrap_here ("    ");
  314.       next_address = VALUE_ADDRESS (val)
  315.     + print_insn (VALUE_ADDRESS (val), gdb_stdout);
  316.       brea