gdb/ch-typeprint.c

   1 /* Support for printing Chill types for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "obstack.h"
  22 #include "bfd.h"                /* Binary File Description */
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "command.h"
  30 #include "gdbcmd.h"
  31 #include "language.h"
  32 #include "demangle.h"
  33 #include "ch-lang.h"
  34 #include "typeprint.h"
  35
  36 #include "gdb_string.h"
  37 #include <errno.h>
  38
  39 static void
  40 chill_type_print_base PARAMS ((struct type *, GDB_FILE *, int, int));
  41
  42 void
  43 chill_print_type (type, varstring, stream, show, level)
  44      struct type *type;
  45      char *varstring;
  46      GDB_FILE *stream;
  47      int show;
  48      int level;
  49 {
  50   if (varstring != NULL && *varstring != '\0')
  51     {
  52       fputs_filtered (varstring, stream);
  53       fputs_filtered (" ", stream);
  54     }
  55   chill_type_print_base (type, stream, show, level);
  56 }
  57
  58 /* Print the name of the type (or the ultimate pointer target,
  59    function value or array element).
  60
  61    SHOW nonzero means don't print this type as just its name;
  62    show its real definition even if it has a name.
  63    SHOW zero means print just typename or tag if there is one
  64    SHOW negative means abbreviate structure elements.
  65    SHOW is decremented for printing of structure elements.
  66
  67    LEVEL is the depth to indent by.
  68    We increase it for some recursive calls.  */
  69
  70 static void
  71 chill_type_print_base (type, stream, show, level)
  72      struct type *type;
  73      GDB_FILE *stream;
  74      int show;
  75      int level;
  76 {
  77   register int len;
  78   register int i;
  79   struct type *index_type;
  80   struct type *range_type;
  81   LONGEST low_bound;
  82   LONGEST high_bound;
  83
  84   QUIT;
  85
  86   wrap_here ("    ");
  87   if (type == NULL)
  88     {
  89       fputs_filtered ("<type unknown>", stream);
  90       return;
  91     }
  92
  93   /* When SHOW is zero or less, and there is a valid type name, then always
  94      just print the type name directly from the type. */
  95
  96   if ((show <= 0) && (TYPE_NAME (type) != NULL))
  97     {
  98       fputs_filtered (TYPE_NAME (type), stream);
  99       return;
 100     }
 101
 102   if (TYPE_CODE (type) != TYPE_CODE_TYPEDEF)
 103     CHECK_TYPEDEF (type);
 104
 105   switch (TYPE_CODE (type))
 106     {
 107       case TYPE_CODE_TYPEDEF:
 108         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
 109         break;
 110       case TYPE_CODE_PTR:
 111         if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
 112           {
 113             fprintf_filtered (stream,
 114                               TYPE_NAME (type) ? TYPE_NAME (type) : "PTR");
 115             break;
 116           }
 117         fprintf_filtered (stream, "REF ");
 118         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
 119         break;
 120
 121       case TYPE_CODE_BOOL:
 122         /* FIXME: we should probably just print the TYPE_NAME, in case
 123            anyone ever fixes the compiler to give us the real names
 124            in the presence of the chill equivalent of typedef (assuming
 125            there is one).  */
 126         fprintf_filtered (stream,
 127                           TYPE_NAME (type) ? TYPE_NAME (type) : "BOOL");
 128         break;
 129
 130       case TYPE_CODE_ARRAY:
 131         fputs_filtered ("ARRAY (", stream);
 132         range_type = TYPE_FIELD_TYPE (type, 0);
 133         if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
 134           chill_print_type (range_type, "", stream, 0, level);
 135         else
 136           {
 137             index_type = TYPE_TARGET_TYPE (range_type);
 138             low_bound = TYPE_FIELD_BITPOS (range_type, 0);
 139             high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 140             print_type_scalar (index_type, low_bound, stream);
 141             fputs_filtered (":", stream);
 142             print_type_scalar (index_type, high_bound, stream);
 143           }
 144         fputs_filtered (") ", stream);
 145         chill_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, level);
 146         break;
 147
 148       case TYPE_CODE_BITSTRING:
 149         fprintf_filtered (stream, "BOOLS (%d)",
 150                           TYPE_FIELD_BITPOS (TYPE_FIELD_TYPE(type,0), 1) + 1);
 151         break;
 152
 153       case TYPE_CODE_SET:
 154         fputs_filtered ("POWERSET ", stream);
 155         chill_print_type (TYPE_INDEX_TYPE (type), "", stream,
 156                           show - 1, level);
 157         break;
 158
 159       case TYPE_CODE_STRING:
 160         range_type = TYPE_FIELD_TYPE (type, 0);
 161         index_type = TYPE_TARGET_TYPE (range_type);
 162         high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 163         fputs_filtered ("CHARS (", stream);
 164         print_type_scalar (index_type, high_bound + 1, stream);
 165         fputs_filtered (")", stream);
 166         break;
 167
 168       case TYPE_CODE_MEMBER:
 169         fprintf_filtered (stream, "MEMBER ");
 170         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
 171         break;
 172       case TYPE_CODE_REF:
 173         fprintf_filtered (stream, "/*LOC*/ ");
 174         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 175         break;
 176       case TYPE_CODE_FUNC:
 177         fprintf_filtered (stream, "PROC (");
 178         len = TYPE_NFIELDS (type);
 179         for (i = 0; i < len; i++)
 180           {
 181             struct type *param_type = TYPE_FIELD_TYPE (type, i);
 182             if (i > 0)
 183               {
 184                 fputs_filtered (", ", stream);
 185                 wrap_here ("    ");
 186               }
 187             if (TYPE_CODE (param_type) == TYPE_CODE_REF)
 188               {
 189                 chill_type_print_base (TYPE_TARGET_TYPE (param_type),
 190                                        stream, 0, level);
 191                 fputs_filtered (" LOC", stream);
 192               }
 193             else
 194               chill_type_print_base (param_type, stream, show, level);
 195           }
 196         fprintf_filtered (stream, ")");
 197         if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
 198           {
 199             fputs_filtered (" RETURNS (", stream);
 200             chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
 201             fputs_filtered (")", stream);
 202           }
 203         break;
 204
 205       case TYPE_CODE_STRUCT:
 206         if (chill_varying_type (type))
 207           {
 208             chill_type_print_base (TYPE_FIELD_TYPE (type, 1),
 209                                    stream, 0, level);
 210             fputs_filtered (" VARYING", stream);
 211           }
 212         else
 213           {
 214             fprintf_filtered (stream, "STRUCT ");
 215
 216             fprintf_filtered (stream, "(\n");
 217             if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 218               {
 219                 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 220                   {
 221                     fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 222                   }
 223                 else
 224                   {
 225                     fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 226                   }
 227               }
 228             else
 229               {
 230                 len = TYPE_NFIELDS (type);
 231                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 232                   {
 233                     struct type *field_type = TYPE_FIELD_TYPE (type, i);
 234                     QUIT;
 235                     print_spaces_filtered (level + 4, stream);
 236                     if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
 237                       { int j; /* variant number */
 238                         fputs_filtered ("CASE OF\n", stream);
 239                         for (j = 0; j < TYPE_NFIELDS (field_type); j++)
 240                           { int k; /* variant field index */
 241                             struct type *variant_type
 242                               = TYPE_FIELD_TYPE (field_type, j);
 243                             int var_len = TYPE_NFIELDS (variant_type);
 244                             print_spaces_filtered (level + 4, stream);
 245                             if (strcmp (TYPE_FIELD_NAME (field_type, j),
 246                                         "else") == 0)
 247                               fputs_filtered ("ELSE\n", stream);
 248                             else
 249                               fputs_filtered (":\n", stream);
 250                             if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
 251                               error ("variant record confusion");
 252                             for (k = 0; k < var_len; k++)
 253                               {
 254                                 print_spaces_filtered (level + 8, stream);
 255                                 chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
 256                                                   TYPE_FIELD_NAME (variant_type, k),
 257                                                   stream, show - 1, level + 8);
 258                                 if (k < (var_len - 1))
 259                                   fputs_filtered (",", stream);
 260                                 fputs_filtered ("\n", stream);
 261                               }
 262                           }
 263                         fputs_filtered ("ESAC\n", stream);
 264                       }
 265                     else
 266                       chill_print_type (field_type,
 267                                         TYPE_FIELD_NAME (type, i),
 268                                         stream, show - 1, level + 4);
 269                     if (i < (len - 1))
 270                       {
 271                         fputs_filtered (",", stream);
 272                       }
 273                     fputs_filtered ("\n", stream);
 274                   }
 275               }
 276             fprintfi_filtered (level, stream, ")");
 277           }
 278         break;
 279
 280       case TYPE_CODE_RANGE:
 281           {
 282             struct type *target = TYPE_TARGET_TYPE (type);
 283             if (target && TYPE_NAME (target))
 284               fputs_filtered (TYPE_NAME (target), stream);
 285             else
 286               fputs_filtered ("RANGE", stream);
 287             if (target == NULL)
 288               target = builtin_type_long;
 289             fputs_filtered (" (", stream);
 290             print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
 291             fputs_filtered (":", stream);
 292             print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
 293             fputs_filtered (")", stream);
 294           }
 295         break;
 296
 297       case TYPE_CODE_ENUM:
 298         {
 299           register int lastval = 0;
 300           fprintf_filtered (stream, "SET (");
 301           len = TYPE_NFIELDS (type);
 302           for (i = 0; i < len; i++)
 303             {
 304               QUIT;
 305               if (i) fprintf_filtered (stream, ", ");
 306               wrap_here ("    ");
 307               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 308               if (lastval != TYPE_FIELD_BITPOS (type, i))
 309                 {
 310                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
 311                   lastval = TYPE_FIELD_BITPOS (type, i);
 312                 }
 313               lastval++;
 314             }
 315           fprintf_filtered (stream, ")");
 316         }
 317         break;
 318
 319       case TYPE_CODE_VOID:
 320       case TYPE_CODE_UNDEF:
 321       case TYPE_CODE_ERROR:
 322       case TYPE_CODE_UNION:
 323       case TYPE_CODE_METHOD:
 324         error ("missing language support in chill_type_print_base");
 325         break;
 326
 327       default:
 328
 329         /* Handle types not explicitly handled by the other cases,
 330            such as fundamental types.  For these, just print whatever
 331            the type name is, as recorded in the type itself.  If there
 332            is no type name, then complain. */
 333
 334         if (TYPE_NAME (type) != NULL)
 335           {
 336             fputs_filtered (TYPE_NAME (type), stream);
 337           }
 338         else
 339           {
 340             error ("Unrecognized type code (%d) in symbol table.",
 341                    TYPE_CODE (type));
 342           }
 343         break;
 344       }
 345 }