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               val_print (VALUE_TYPE (deref_val),
 464                          VALUE_CONTENTS (deref_val),
 465                          VALUE_ADDRESS (deref_val), stream, format,
 466                          deref_ref, recurse + 1, pretty);
 467             }
 468           else
 469             fputs_filtered ("???", stream);
 470         }
 471       break;
 472
 473     case TYPE_CODE_ENUM:
 474       c_val_print (type, valaddr, address, stream, format,
 475                    deref_ref, recurse, pretty);
 476       break;
 477
 478     case TYPE_CODE_RANGE:
 479       if (TYPE_TARGET_TYPE (type))
 480         chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
 481                          format, deref_ref, recurse, pretty);
 482       break;
 483
 484     case TYPE_CODE_MEMBER:
 485     case TYPE_CODE_UNION:
 486     case TYPE_CODE_FUNC:
 487     case TYPE_CODE_VOID:
 488     case TYPE_CODE_ERROR:
 489     default:
 490       /* Let's defer printing to the C printer, rather than
 491          print an error message.  FIXME! */
 492       c_val_print (type, valaddr, address, stream, format,
 493                    deref_ref, recurse, pretty);
 494     }
 495   gdb_flush (stream);
 496   return (0);
 497 }
 498
 499 /* Mutually recursive subroutines of cplus_print_value and c_val_print to
 500    print out a structure's fields: cp_print_value_fields and cplus_print_value.
 501
 502    TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
 503    same meanings as in cplus_print_value and c_val_print.
 504
 505    DONT_PRINT is an array of baseclass types that we
 506    should not print, or zero if called from top level.  */
 507
 508 static void
 509 chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
 510                           dont_print)
 511      struct type *type;
 512      char *valaddr;
 513      GDB_FILE *stream;
 514      int format;
 515      int recurse;
 516      enum val_prettyprint pretty;
 517      struct type **dont_print;
 518 {
 519   int i, len;
 520   int fields_seen = 0;
 521
 522   CHECK_TYPEDEF (type);
 523
 524   fprintf_filtered (stream, "[");
 525   len = TYPE_NFIELDS (type);
 526   if (len == 0)
 527     {
 528       fprintf_filtered (stream, "<No data fields>");
 529     }
 530   else
 531     {
 532       for (i = 0; i < len; i++)
 533         {
 534           if (fields_seen)
 535             {
 536               fprintf_filtered (stream, ", ");
 537             }
 538           fields_seen = 1;
 539           if (pretty)
 540             {
 541               fprintf_filtered (stream, "\n");
 542               print_spaces_filtered (2 + 2 * recurse, stream);
 543             }
 544           else
 545             {
 546               wrap_here (n_spaces (2 + 2 * recurse));
 547             }
 548           fputs_filtered (".", stream);
 549           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 550                                    language_chill, DMGL_NO_OPTS);
 551           fputs_filtered (": ", stream);
 552           if (TYPE_FIELD_PACKED (type, i))
 553             {
 554               value_ptr v;
 555
 556               /* Bitfields require special handling, especially due to byte
 557                  order problems.  */
 558               v = value_from_longest (TYPE_FIELD_TYPE (type, i),
 559                                       unpack_field_as_long (type, valaddr, i));
 560
 561               chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
 562                                stream, format, 0, recurse + 1, pretty);
 563             }
 564           else
 565             {
 566               chill_val_print (TYPE_FIELD_TYPE (type, i),
 567                                valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
 568                                0, stream, format, 0, recurse + 1, pretty);
 569             }
 570         }
 571       if (pretty)
 572         {
 573           fprintf_filtered (stream, "\n");
 574           print_spaces_filtered (2 * recurse, stream);
 575         }
 576     }
 577   fprintf_filtered (stream, "]");
 578 }
 579 \f
 580 int
 581 chill_value_print (val, stream, format, pretty)
 582      value_ptr val;
 583      GDB_FILE *stream;
 584      int format;
 585      enum val_prettyprint pretty;
 586 {
 587   struct type *type = VALUE_TYPE (val);
 588   struct type *real_type = check_typedef  (type);
 589
 590   /* If it is a pointer, indicate what it points to.
 591
 592      Print type also if it is a reference. */
 593
 594   if (TYPE_CODE (real_type) == TYPE_CODE_PTR ||
 595       TYPE_CODE (real_type) == TYPE_CODE_REF)
 596     {
 597       char *valaddr = VALUE_CONTENTS (val);
 598       CORE_ADDR addr = unpack_pointer (type, valaddr);
 599       if (TYPE_CODE (type) != TYPE_CODE_PTR || addr != 0)
 600         {
 601           int i;
 602           char *name = TYPE_NAME (type);
 603           if (name)
 604             fputs_filtered (name, stream);
 605           else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
 606             fputs_filtered ("PTR", stream);
 607           else
 608             {
 609               fprintf_filtered (stream, "(");
 610               type_print (type, "", stream, -1);
 611               fprintf_filtered (stream, ")");
 612             }
 613           fprintf_filtered (stream, "(");
 614           i = val_print (type, valaddr, VALUE_ADDRESS (val),
 615                          stream, format, 1, 0, pretty);
 616           fprintf_filtered (stream, ")");
 617           return i;
 618         }
 619     }
 620   return (val_print (type, VALUE_CONTENTS (val),
 621                      VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
 622 }
 623
 624