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 #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 \f
  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 \f
  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 \f
 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