gdb/ch-valprint.c

   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
  32 static void
  33 chill_print_value_fields PARAMS ((struct type *, char *, GDB_FILE *, int, int,
  34                                   enum val_prettyprint, struct type **));
  35
  36 \f
  37 /* Print data of type TYPE located at VALADDR (within GDB), which came from
  38    the inferior at address ADDRESS, onto stdio stream STREAM according to
  39    FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
  40    target byte order.
  41
  42    If the data are a string pointer, returns the number of string characters
  43    printed.
  44
  45    If DEREF_REF is nonzero, then dereference references, otherwise just print
  46    them like pointers.
  47
  48    The PRETTY parameter controls prettyprinting.  */
  49
  50 int
  51 chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
  52                  pretty)
  53      struct type *type;
  54      char *valaddr;
  55      CORE_ADDR address;
  56      GDB_FILE *stream;
  57      int format;
  58      int deref_ref;
  59      int recurse;
  60      enum val_prettyprint pretty;
  61 {
  62   LONGEST val;
  63   unsigned int i = 0;           /* Number of characters printed.  */
  64   struct type *elttype;
  65   CORE_ADDR addr;
  66
  67   switch (TYPE_CODE (type))
  68     {
  69     case TYPE_CODE_ARRAY:
  70       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
  71         {
  72           if (prettyprint_arrays)
  73             {
  74               print_spaces_filtered (2 + 2 * recurse, stream);
  75             }
  76           fprintf_filtered (stream, "[");
  77           val_print_array_elements (type, valaddr, address, stream, format,
  78                                     deref_ref, recurse, pretty, 0);
  79           fprintf_filtered (stream, "]");
  80         }
  81       else
  82         {
  83           error ("unimplemented in chill_val_print; unspecified array length");
  84         }
  85       break;
  86
  87     case TYPE_CODE_INT:
  88       format = format ? format : output_format;
  89       if (format)
  90         {
  91           print_scalar_formatted (valaddr, type, format, 0, stream);
  92         }
  93       else
  94         {
  95           val_print_type_code_int (type, valaddr, stream);
  96         }
  97       break;
  98
  99     case TYPE_CODE_CHAR:
 100       format = format ? format : output_format;
 101       if (format)
 102         {
 103           print_scalar_formatted (valaddr, type, format, 0, stream);
 104         }
 105       else
 106         {
 107           LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
 108                          stream);
 109         }
 110       break;
 111
 112     case TYPE_CODE_FLT:
 113       if (format)
 114         {
 115           print_scalar_formatted (valaddr, type, format, 0, stream);
 116         }
 117       else
 118         {
 119           print_floating (valaddr, type, stream);
 120         }
 121       break;
 122
 123     case TYPE_CODE_BOOL:
 124       format = format ? format : output_format;
 125       if (format)
 126         {
 127           print_scalar_formatted (valaddr, type, format, 0, stream);
 128         }
 129       else
 130         {
 131           /* FIXME: Why is this using builtin_type_chill_bool not type?  */
 132           val = unpack_long (builtin_type_chill_bool, valaddr);
 133           fprintf_filtered (stream, val ? "TRUE" : "FALSE");
 134         }
 135       break;
 136
 137     case TYPE_CODE_UNDEF:
 138       /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
 139          dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
 140          and no complete type for struct foo in that file.  */
 141       fprintf_filtered (stream, "<incomplete type>");
 142       break;
 143
 144     case TYPE_CODE_PTR:
 145       if (format && format != 's')
 146         {
 147           print_scalar_formatted (valaddr, type, format, 0, stream);
 148           break;
 149         }
 150       addr = unpack_pointer (type, valaddr);
 151       elttype = TYPE_TARGET_TYPE (type);
 152
 153       if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 154         {
 155           /* Try to print what function it points to.  */
 156           print_address_demangle (addr, stream, demangle);
 157           /* Return value is irrelevant except for string pointers.  */
 158           return (0);
 159         }
 160       if (addressprint && format != 's')
 161         {
 162           print_address_numeric (addr, stream);
 163         }
 164
 165       /* For a pointer to char or unsigned char, also print the string
 166          pointed to, unless pointer is null.  */
 167       if (TYPE_LENGTH (elttype) == 1
 168           && TYPE_CODE (elttype) == TYPE_CODE_CHAR
 169           && (format == 0 || format == 's')
 170           && addr != 0
 171           && /* If print_max is UINT_MAX, the alloca below will fail.
 172                 In that case don't try to print the string.  */
 173           print_max < UINT_MAX)
 174           {
 175             i = val_print_string (addr, 0, stream);
 176           }
 177       /* Return number of characters printed, plus one for the
 178          terminating null if we have "reached the end".  */
 179       return (i + (print_max && i != print_max));
 180       break;
 181
 182     case TYPE_CODE_STRING:
 183       if (format && format != 's')
 184         {
 185           print_scalar_formatted (valaddr, type, format, 0, stream);
 186           break;
 187         }
 188       i = TYPE_LENGTH (type);
 189       LA_PRINT_STRING (stream, valaddr, i, 0);
 190       /* Return number of characters printed, plus one for the terminating
 191          null if we have "reached the end".  */
 192       return (i + (print_max && i != print_max));
 193       break;
 194
 195     case TYPE_CODE_BITSTRING:
 196     case TYPE_CODE_SET:
 197       {
 198         struct type *range = TYPE_FIELD_TYPE (type, 0);
 199         int low_bound = TYPE_LOW_BOUND (range);
 200         int high_bound = TYPE_HIGH_BOUND (range);
 201         int i;
 202         int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
 203         int need_comma = 0;
 204         int in_range = 0;
 205
 206         if (is_bitstring)
 207           fputs_filtered ("B'", stream);
 208         else
 209           fputs_filtered ("[", stream);
 210         for (i = low_bound; i <= high_bound; i++)
 211           {
 212             int element = value_bit_index (type, valaddr, i);
 213             if (is_bitstring)
 214               fprintf_filtered (stream, "%d", element);
 215             else if (element)
 216               {
 217                 if (need_comma)
 218                   fputs_filtered (", ", stream);
 219                 print_type_scalar (TYPE_TARGET_TYPE (range), i, stream);
 220                 need_comma = 1;
 221
 222                 /* Look for a continuous range of true elements. */
 223                 if (i+1 <= high_bound && value_bit_index (type, valaddr, ++i))
 224                   {
 225                     int j = i; /* j is the upper bound so far of the range */
 226                     fputs_filtered (":", stream);
 227                     while (i+1 <= high_bound
 228                            && value_bit_index (type, valaddr, ++i))
 229                       j = i;
 230                     print_type_scalar (TYPE_TARGET_TYPE (range), j, stream);
 231                   }
 232               }
 233           }
 234         if (is_bitstring)
 235           fputs_filtered ("'", stream);
 236         else
 237           fputs_filtered ("]", stream);
 238       }
 239       break;
 240
 241     case TYPE_CODE_STRUCT:
 242       if (chill_is_varying_struct (type))
 243         {
 244           struct type *inner = TYPE_FIELD_TYPE (type, 1);
 245           long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
 246           char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
 247
 248           switch (TYPE_CODE (inner))
 249             {
 250             case TYPE_CODE_STRING:
 251               if (length > TYPE_LENGTH (type))
 252                 {
 253                   fprintf_filtered (stream,
 254                                     "<dynamic length %d > static length %d>",
 255                                     length, TYPE_LENGTH (type));
 256                   length > TYPE_LENGTH (type);
 257                 }
 258               LA_PRINT_STRING (stream, data_addr, length, 0);
 259               return length;
 260             }
 261         }
 262       chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
 263                                 0);
 264       break;
 265
 266     case TYPE_CODE_REF:
 267       if (addressprint)
 268         {
 269           fprintf_filtered (stream, "LOC(");
 270           print_address_numeric
 271             (extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
 272              stream);
 273           fprintf_filtered (stream, ")");
 274           if (deref_ref)
 275             fputs_filtered (": ", stream);
 276         }
 277       /* De-reference the reference.  */
 278       if (deref_ref)
 279         {
 280           if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
 281             {
 282               value deref_val =
 283                 value_at
 284                   (TYPE_TARGET_TYPE (type),
 285                    unpack_pointer (lookup_pointer_type (builtin_type_void),
 286                                    valaddr));
 287               val_print (VALUE_TYPE (deref_val),
 288                          VALUE_CONTENTS (deref_val),
 289                          VALUE_ADDRESS (deref_val), stream, format,
 290                          deref_ref, recurse + 1, pretty);
 291             }
 292           else
 293             fputs_filtered ("???", stream);
 294         }
 295       break;
 296
 297     case TYPE_CODE_ENUM:
 298       c_val_print (type, valaddr, address, stream, format,
 299                    deref_ref, recurse, pretty);
 300       break;
 301
 302     case TYPE_CODE_RANGE:
 303       if (TYPE_TARGET_TYPE (type))
 304         chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
 305                          format, deref_ref, recurse, pretty);
 306       break;
 307
 308     case TYPE_CODE_MEMBER:
 309     case TYPE_CODE_UNION:
 310     case TYPE_CODE_FUNC:
 311     case TYPE_CODE_VOID:
 312     case TYPE_CODE_ERROR:
 313     default:
 314       /* Let's defer printing to the C printer, rather than
 315          print an error message.  FIXME! */
 316       c_val_print (type, valaddr, address, stream, format,
 317                    deref_ref, recurse, pretty);
 318     }
 319   gdb_flush (stream);
 320   return (0);
 321 }
 322
 323 /* Mutually recursive subroutines of cplus_print_value and c_val_print to
 324    print out a structure's fields: cp_print_value_fields and cplus_print_value.
 325
 326    TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
 327    same meanings as in cplus_print_value and c_val_print.
 328
 329    DONT_PRINT is an array of baseclass types that we
 330    should not print, or zero if called from top level.  */
 331
 332 static void
 333 chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
 334                           dont_print)
 335      struct type *type;
 336      char *valaddr;
 337      GDB_FILE *stream;
 338      int format;
 339      int recurse;
 340      enum val_prettyprint pretty;
 341      struct type **dont_print;
 342 {
 343   int i, len;
 344   int fields_seen = 0;
 345
 346   check_stub_type (type);
 347
 348   fprintf_filtered (stream, "[");
 349   len = TYPE_NFIELDS (type);
 350   if (len == 0)
 351     {
 352       fprintf_filtered (stream, "<No data fields>");
 353     }
 354   else
 355     {
 356       for (i = 0; i < len; i++)
 357         {
 358           if (fields_seen)
 359             {
 360               fprintf_filtered (stream, ", ");
 361             }
 362           fields_seen = 1;
 363           if (pretty)
 364             {
 365               fprintf_filtered (stream, "\n");
 366               print_spaces_filtered (2 + 2 * recurse, stream);
 367             }
 368           else
 369             {
 370               wrap_here (n_spaces (2 + 2 * recurse));
 371             }
 372           fputs_filtered (".", stream);
 373           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 374                                    language_chill, DMGL_NO_OPTS);
 375           fputs_filtered (": ", stream);
 376           if (TYPE_FIELD_PACKED (type, i))
 377             {
 378               value v;
 379
 380               /* Bitfields require special handling, especially due to byte
 381                  order problems.  */
 382               v = value_from_longest (TYPE_FIELD_TYPE (type, i),
 383                                       unpack_field_as_long (type, valaddr, i));
 384
 385               chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
 386                                stream, format, 0, recurse + 1, pretty);
 387             }
 388           else
 389             {
 390               chill_val_print (TYPE_FIELD_TYPE (type, i),
 391                                valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
 392                                0, stream, format, 0, recurse + 1, pretty);
 393             }
 394         }
 395       if (pretty)
 396         {
 397           fprintf_filtered (stream, "\n");
 398           print_spaces_filtered (2 * recurse, stream);
 399         }
 400     }
 401   fprintf_filtered (stream, "]");
 402 }