home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / gnu / gdb-4.14-src.lha / gdb-4.14 / gdb / ch-valprint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-02  |  16.0 KB  |  602 lines
  1. /* Support for printing Chill values for GDB, the GNU debugger.
  2.    Copyright 1986, 1988, 1989, 1991, 1992, 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 "obstack.h"
  23. #include "symtab.h"
  24. #include "gdbtypes.h"
  25. #include "valprint.h"
  26. #include "expression.h"
  27. #include "value.h"
  28. #include "language.h"
  29. #include "demangle.h"
  30. #include "c-lang.h" /* For c_val_print */
  31. #include "typeprint.h"
  32. #include "ch-lang.h"
  33.  
  34. static void
  35. chill_print_value_fields PARAMS ((struct type *, char *, GDB_FILE *, int, int,
  36.                   enum val_prettyprint, struct type **));
  37.  
  38.  
  39. /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
  40.    Used to print data from type structures in a specified type.  For example,
  41.    array bounds may be characters or booleans in some languages, and this
  42.    allows the ranges to be printed in their "natural" form rather than as
  43.    decimal integer values. */
  44.  
  45. void
  46. chill_print_type_scalar (type, val, stream)
  47.      struct type *type;
  48.      LONGEST val;
  49.      GDB_FILE *stream;
  50. {
  51.   switch (TYPE_CODE (type))
  52.     {
  53.     case TYPE_CODE_RANGE:
  54.       if (TYPE_TARGET_TYPE (type))
  55.     {
  56.       chill_print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
  57.       return;
  58.     }
  59.     }
  60.   print_type_scalar (type, val, stream);
  61. }
  62.  
  63. /* Print the elements of an array.
  64.    Similar to val_print_array_elements, but prints
  65.    element indexes (in Chill syntax). */
  66.  
  67. static void
  68. chill_val_print_array_elements (type, valaddr, address, stream,
  69.                 format, deref_ref, recurse, pretty)
  70.      struct type *type;
  71.      char *valaddr;
  72.      CORE_ADDR address;
  73.      GDB_FILE *stream;
  74.      int format;
  75.      int deref_ref;
  76.      int recurse;
  77.      enum val_prettyprint pretty;
  78. {
  79.   unsigned int i = 0;
  80.   unsigned int things_printed = 0;
  81.   unsigned len;
  82.   struct type *elttype;
  83.   struct type *range_type = TYPE_FIELD_TYPE (type, 0);
  84.   struct type *index_type = TYPE_TARGET_TYPE (range_type);
  85.   unsigned eltlen;
  86.   /* Position of the array element we are examining to see
  87.      whether it is repeated.  */
  88.   unsigned int rep1;
  89.   /* Number of repetitions we have detected so far.  */
  90.   unsigned int reps;
  91.   LONGEST low_bound =  TYPE_FIELD_BITPOS (range_type, 0);
  92.   LONGEST high_bound = TYPE_FIELD_BITPOS (range_type, 1);
  93.       
  94.   elttype = TYPE_TARGET_TYPE (type);
  95.   eltlen = TYPE_LENGTH (elttype);
  96.   len = TYPE_LENGTH (type) / eltlen;
  97.  
  98.   annotate_array_section_begin (i, elttype);
  99.  
  100.   for (; i < len && things_printed < print_max; i++)
  101.     {
  102.       if (i != 0)
  103.     {
  104.       if (prettyprint_arrays)
  105.         {
  106.           fprintf_filtered (stream, ",\n");
  107.           print_spaces_filtered (2 + 2 * recurse, stream);
  108.         }
  109.       else
  110.         {
  111.           fprintf_filtered (stream, ", ");
  112.         }
  113.     }
  114.       wrap_here (n_spaces (2 + 2 * recurse));
  115.  
  116.       rep1 = i + 1;
  117.       reps = 1;
  118.       while ((rep1 < len) && 
  119.          !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
  120.     {
  121.       ++reps;
  122.       ++rep1;
  123.     }
  124.  
  125.       fputs_filtered ("(", stream);
  126.       chill_print_type_scalar (index_type, low_bound + i, stream);
  127.       if (reps > 1)
  128.     {
  129.       fputs_filtered (":", stream);
  130.       chill_print_type_scalar (index_type, low_bound + i + reps - 1,
  131.                    stream);
  132.       fputs_filtered ("): ", stream);
  133.       val_print (elttype, valaddr + i * eltlen, 0, stream, format,
  134.              deref_ref, recurse + 1, pretty);
  135.  
  136.       i = rep1 - 1;
  137.       things_printed += 1;
  138.     }
  139.       else
  140.     {
  141.       fputs_filtered ("): ", stream);
  142.       val_print (elttype, valaddr + i * eltlen, 0, stream, format,
  143.              deref_ref, recurse + 1, pretty);
  144.       annotate_elt ();
  145.       things_printed++;
  146.     }
  147.     }
  148.   annotate_array_section_end ();
  149.   if (i < len)
  150.     {
  151.       fprintf_filtered (stream, "...");
  152.     }
  153. }
  154.  
  155. /* Print data of type TYPE located at VALADDR (within GDB), which came from
  156.    the inferior at address ADDRESS, onto stdio stream STREAM according to
  157.    FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
  158.    target byte order.
  159.  
  160.    If the data are a string pointer, returns the number of string characters
  161.    printed.
  162.  
  163.    If DEREF_REF is nonzero, then dereference references, otherwise just print
  164.    them like pointers.
  165.  
  166.    The PRETTY parameter controls prettyprinting.  */
  167.  
  168. int
  169. chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
  170.          pretty)
  171.      struct type *type;
  172.      char *valaddr;
  173.      CORE_ADDR address;
  174.      GDB_FILE *stream;
  175.      int format;
  176.      int deref_ref;
  177.      int recurse;
  178.      enum val_prettyprint pretty;
  179. {
  180.   LONGEST val;
  181.   unsigned int i = 0;        /* Number of characters printed.  */
  182.   struct type *elttype;
  183.   CORE_ADDR addr;
  184.  
  185.   switch (TYPE_CODE (type))
  186.     {
  187.     case TYPE_CODE_ARRAY:
  188.       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
  189.     {
  190.       if (prettyprint_arrays)
  191.         {
  192.           print_spaces_filtered (2 + 2 * recurse, stream);
  193.         }
  194.       fprintf_filtered (stream, "[");
  195.       chill_val_print_array_elements (type, valaddr, address, stream,
  196.                       format, deref_ref, recurse, pretty);
  197.       fprintf_filtered (stream, "]");
  198.     }
  199.       else
  200.     {
  201.       error ("unimplemented in chill_val_print; unspecified array length");
  202.     }
  203.       break;
  204.  
  205.     case TYPE_CODE_INT:
  206.       format = format ? format : output_format;
  207.       if (format)
  208.     {
  209.       print_scalar_formatted (valaddr, type, format, 0, stream);
  210.     }
  211.       else
  212.     {
  213.       val_print_type_code_int (type, valaddr, stream);
  214.     }
  215.       break;
  216.  
  217.     case TYPE_CODE_CHAR:
  218.       format = format ? format : output_format;
  219.       if (format)
  220.     {
  221.       print_scalar_formatted (valaddr, type, format, 0, stream);
  222.     }
  223.       else
  224.     {
  225.       LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
  226.              stream);
  227.     }
  228.       break;
  229.  
  230.     case TYPE_CODE_FLT:
  231.       if (format)
  232.     {
  233.       print_scalar_formatted (valaddr, type, format, 0, stream);
  234.     }
  235.       else
  236.     {
  237.       print_floating (valaddr, type, stream);
  238.     }
  239.       break;
  240.  
  241.     case TYPE_CODE_BOOL:
  242.       format = format ? format : output_format;
  243.       if (format)
  244.     {
  245.       print_scalar_formatted (valaddr, type, format, 0, stream);
  246.     }
  247.       else
  248.     {
  249.       /* FIXME: Why is this using builtin_type_chill_bool not type?  */
  250.       val = unpack_long (builtin_type_chill_bool, valaddr);
  251.       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
  252.     }
  253.       break;
  254.  
  255.     case TYPE_CODE_UNDEF:
  256.       /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
  257.      dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
  258.      and no complete type for struct foo in that file.  */
  259.       fprintf_filtered (stream, "<incomplete type>");
  260.       break;
  261.  
  262.     case TYPE_CODE_PTR:
  263.       if (format && format != 's')
  264.     {
  265.       print_scalar_formatted (valaddr, type, format, 0, stream);
  266.       break;
  267.     }
  268.       addr = unpack_pointer (type, valaddr);
  269.       elttype = TYPE_TARGET_TYPE (type);
  270.  
  271.       /* We assume a NULL pointer is all zeros ... */
  272.       if (addr == 0)
  273.     {
  274.       fputs_filtered ("NULL", stream);
  275.       return 0;
  276.     }
  277.       
  278.       if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
  279.     {
  280.       /* Try to print what function it points to.  */
  281.       print_address_demangle (addr, stream, demangle);
  282.       /* Return value is irrelevant except for string pointers.  */
  283.       return (0);
  284.     }
  285.       if (addressprint && format != 's')
  286.     {
  287.       print_address_numeric (addr, 1, stream);
  288.     }
  289.       
  290.       /* For a pointer to char or unsigned char, also print the string
  291.      pointed to, unless pointer is null.  */
  292.       if (TYPE_LENGTH (elttype) == 1
  293.       && TYPE_CODE (elttype) == TYPE_CODE_CHAR
  294.       && (format == 0 || format == 's')
  295.       && addr != 0
  296.       && /* If print_max is UINT_MAX, the alloca below will fail.
  297.         In that case don't try to print the string.  */
  298.       print_max < UINT_MAX)
  299.       {
  300.         i = val_print_string (addr, 0, stream);
  301.       }
  302.       /* Return number of characters printed, plus one for the
  303.      terminating null if we have "reached the end".  */
  304.       return (i + (print_max && i != print_max));
  305.       break;
  306.  
  307.     case TYPE_CODE_STRING:
  308.       i = TYPE_LENGTH (type);
  309.       LA_PRINT_STRING (stream, valaddr, i, 0);
  310.       /* Return number of characters printed, plus one for the terminating
  311.      null if we have "reached the end".  */
  312.       return (i + (print_max && i != print_max));
  313.       break;
  314.  
  315.     case TYPE_CODE_BITSTRING:
  316.     case TYPE_CODE_SET:
  317.       elttype = TYPE_INDEX_TYPE (type);
  318.       check_stub_type (elttype);
  319.       if (TYPE_FLAGS (elttype) & TYPE_FLAG_STUB)
  320.     {
  321.       fprintf_filtered (stream, "<incomplete type>");
  322.       gdb_flush (stream);
  323.       break;
  324.     }
  325.       {
  326.     struct type *range = elttype;
  327.     int low_bound = TYPE_LOW_BOUND (range);
  328.     int high_bound = TYPE_HIGH_BOUND (range);
  329.     int i;
  330.     int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
  331.     int need_comma = 0;
  332.  
  333.     if (is_bitstring)
  334.       fputs_filtered ("B'", stream);
  335.     else
  336.       fputs_filtered ("[", stream);
  337.     for (i = low_bound; i <= high_bound; i++)
  338.       {
  339.         int element = value_bit_index (type, valaddr, i);
  340.         if (is_bitstring)
  341.           fprintf_filtered (stream, "%d", element);
  342.         else if (element)
  343.           {
  344.         if (need_comma)
  345.           fputs_filtered (", ", stream);
  346.         chill_print_type_scalar (range, i, stream);
  347.         need_comma = 1;
  348.  
  349.         /* Look for a continuous range of true elements. */
  350.         if (i+1 <= high_bound && value_bit_index (type, valaddr, ++i))
  351.           {
  352.             int j = i; /* j is the upper bound so far of the range */
  353.             fputs_filtered (":", stream);
  354.             while (i+1 <= high_bound
  355.                && value_bit_index (type, valaddr, ++i))
  356.               j = i;
  357.             chill_print_type_scalar (range, j, stream);
  358.           }
  359.           }
  360.       }
  361.     if (is_bitstring)
  362.       fputs_filtered ("'", stream);
  363.     else
  364.       fputs_filtered ("]", stream);
  365.       }
  366.       break;
  367.  
  368.     case TYPE_CODE_STRUCT:
  369.       if (chill_varying_type (type))
  370.     {
  371.       struct type *inner = TYPE_FIELD_TYPE (type, 1);
  372.       long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
  373.       char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
  374.       
  375.       switch (TYPE_CODE (inner))
  376.         {
  377.         case TYPE_CODE_STRING:
  378.           if (length > TYPE_LENGTH (type))
  379.         {
  380.           fprintf_filtered (stream,
  381.                     "<dynamic length %d > static length %d>",
  382.                     length, TYPE_LENGTH (type));
  383.         }
  384.           LA_PRINT_STRING (stream, data_addr, length, 0);
  385.           return length;
  386.         default:
  387.           break;
  388.         }
  389.     }
  390.       chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
  391.                 0);
  392.       break;
  393.  
  394.     case TYPE_CODE_REF:
  395.       if (addressprint)
  396.         {
  397.       fprintf_filtered (stream, "LOC(");
  398.       print_address_numeric
  399.         (extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
  400.          1,
  401.          stream);
  402.       fprintf_filtered (stream, ")");
  403.       if (deref_ref)
  404.         fputs_filtered (": ", stream);
  405.         }
  406.       /* De-reference the reference.  */
  407.       if (deref_ref)
  408.     {
  409.       if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
  410.         {
  411.           value_ptr deref_val =
  412.         value_at
  413.           (TYPE_TARGET_TYPE (type),
  414.            unpack_pointer (lookup_pointer_type (builtin_type_void),
  415.                    valaddr));
  416.           val_print (VALUE_TYPE (deref_val),
  417.              VALUE_CONTENTS (deref_val),
  418.              VALUE_ADDRESS (deref_val), stream, format,
  419.              deref_ref, recurse + 1, pretty);
  420.         }
  421.       else
  422.         fputs_filtered ("???", stream);
  423.     }
  424.       break;
  425.  
  426.     case TYPE_CODE_ENUM:
  427.       c_val_print (type, valaddr, address, stream, format,
  428.            deref_ref, recurse, pretty);
  429.       break;
  430.  
  431.     case TYPE_CODE_RANGE:
  432.       if (TYPE_TARGET_TYPE (type))
  433.     chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
  434.              format, deref_ref, recurse, pretty);
  435.       break;
  436.  
  437.     case TYPE_CODE_MEMBER:
  438.     case TYPE_CODE_UNION:
  439.     case TYPE_CODE_FUNC:
  440.     case TYPE_CODE_VOID:
  441.     case TYPE_CODE_ERROR:
  442.     default:
  443.       /* Let's defer printing to the C printer, rather than
  444.      print an error message.  FIXME! */
  445.       c_val_print (type, valaddr, address, stream, format,
  446.            deref_ref, recurse, pretty);
  447.     }
  448.   gdb_flush (stream);
  449.   return (0);
  450. }
  451.  
  452. /* Mutually recursive subroutines of cplus_print_value and c_val_print to
  453.    print out a structure's fields: cp_print_value_fields and cplus_print_value.
  454.  
  455.    TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
  456.    same meanings as in cplus_print_value and c_val_print.
  457.  
  458.    DONT_PRINT is an array of baseclass types that we
  459.    should not print, or zero if called from top level.  */
  460.  
  461. static void
  462. chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
  463.               dont_print)
  464.      struct type *type;
  465.      char *valaddr;
  466.      GDB_FILE *stream;
  467.      int format;
  468.      int recurse;
  469.      enum val_prettyprint pretty;
  470.      struct type **dont_print;
  471. {
  472.   int i, len;
  473.   int fields_seen = 0;
  474.  
  475.   check_stub_type (type);
  476.  
  477.   fprintf_filtered (stream, "[");
  478.   len = TYPE_NFIELDS (type);
  479.   if (len == 0)
  480.     {
  481.       fprintf_filtered (stream, "<No data fields>");
  482.     }
  483.   else
  484.     {
  485.       for (i = 0; i < len; i++)
  486.     {
  487.       if (fields_seen)
  488.         {
  489.           fprintf_filtered (stream, ", ");
  490.         }
  491.       fields_seen = 1;
  492.       if (pretty)
  493.         {
  494.           fprintf_filtered (stream, "\n");
  495.           print_spaces_filtered (2 + 2 * recurse, stream);
  496.         }
  497.       else 
  498.         {
  499.           wrap_here (n_spaces (2 + 2 * recurse));
  500.         }
  501.       fputs_filtered (".", stream);
  502.       fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
  503.                    language_chill, DMGL_NO_OPTS);
  504.       fputs_filtered (": ", stream);
  505.       if (TYPE_FIELD_PACKED (type, i))
  506.         {
  507.           value_ptr v;
  508.  
  509.           /* Bitfields require special handling, especially due to byte
  510.          order problems.  */
  511.           v = value_from_longest (TYPE_FIELD_TYPE (type, i),
  512.                       unpack_field_as_long (type, valaddr, i));
  513.  
  514.           chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
  515.                    stream, format, 0, recurse + 1, pretty);
  516.         }
  517.       else
  518.         {
  519.           chill_val_print (TYPE_FIELD_TYPE (type, i), 
  520.                    valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
  521.                    0, stream, format, 0, recurse + 1, pretty);
  522.         }
  523.     }
  524.       if (pretty)
  525.     {
  526.       fprintf_filtered (stream, "\n");
  527.       print_spaces_filtered (2 * recurse, stream);
  528.     }
  529.     }
  530.   fprintf_filtered (stream, "]");
  531. }
  532.  
  533. int
  534. chill_value_print (val, stream, format, pretty)
  535.      value_ptr val;
  536.      GDB_FILE *stream;
  537.      int format;
  538.      enum val_prettyprint pretty;
  539. {
  540.   /* A "repeated" value really contains several values in a row.
  541.      They are made by the @ operator.
  542.      Print such values as if they were arrays.  */
  543.  
  544.   if (VALUE_REPEATED (val))
  545.     {
  546.       register unsigned int n = VALUE_REPETITIONS (val);
  547.       register unsigned int typelen = TYPE_LENGTH (VALUE_TYPE (val));
  548.       fprintf_filtered (stream, "[");
  549.       /* Print arrays of characters using string syntax.  */
  550.       if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT
  551.       && format == 0)
  552.     LA_PRINT_STRING (stream, VALUE_CONTENTS (val), n, 0);
  553.       else
  554.     {
  555.       value_print_array_elements (val, stream, format, pretty);
  556.     }
  557.       fprintf_filtered (stream, "]");
  558.       return (n * typelen);
  559.     }
  560.   else
  561.     {
  562.       struct type *type = VALUE_TYPE (val);
  563.  
  564.       /* If it is a pointer, indicate what it points to.
  565.  
  566.      Print type also if it is a reference.
  567.  
  568.          C++: if it is a member pointer, we will take care
  569.      of that when we print it.  */
  570.       if (TYPE_CODE (type) == TYPE_CODE_PTR ||
  571.       TYPE_CODE (type) == TYPE_CODE_REF)
  572.     {
  573.       char *valaddr = VALUE_CONTENTS (val);
  574.       CORE_ADDR addr = unpack_pointer (type, valaddr);
  575.           if (TYPE_CODE (type) != TYPE_CODE_PTR || addr != 0)
  576.         {
  577.           int i;
  578.           char *name = TYPE_NAME (type);
  579.           if (name)
  580.         fputs_filtered (name, stream);
  581.           else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
  582.         fputs_filtered ("PTR", stream);
  583.           else
  584.         {
  585.           fprintf_filtered (stream, "(");
  586.           type_print (type, "", stream, -1);
  587.           fprintf_filtered (stream, ")");
  588.         }
  589.           fprintf_filtered (stream, "(");
  590.           i = val_print (type, valaddr, VALUE_ADDRESS (val),
  591.                  stream, format, 1, 0, pretty);
  592.           fprintf_filtered (stream, ")");
  593.           return i;
  594.         }
  595.     }
  596.       return (val_print (type, VALUE_CONTENTS (val),
  597.              VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
  598.     }
  599. }
  600.  
  601.  
  602.