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