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., 675 Mass Ave, Cambridge, MA 02139, 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 <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   char *name;
  78   register int len;
  79   register int i;
  80   struct type *index_type;
  81   struct type *range_type;
  82   LONGEST low_bound;
  83   LONGEST high_bound;
  84
  85   QUIT;
  86
  87   wrap_here ("    ");
  88   if (type == NULL)
  89     {
  90       fputs_filtered ("<type unknown>", stream);
  91       return;
  92     }
  93
  94   /* When SHOW is zero or less, and there is a valid type name, then always
  95      just print the type name directly from the type. */
  96
  97   if ((show <= 0) && (TYPE_NAME (type) != NULL))
  98     {
  99       fputs_filtered (TYPE_NAME (type), stream);
 100       return;
 101     }
 102
 103   check_stub_type (type);
 104
 105   switch (TYPE_CODE (type))
 106     {
 107       case TYPE_CODE_PTR:
 108         if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
 109           {
 110             fprintf_filtered (stream, "PTR");
 111             break;
 112           }
 113         fprintf_filtered (stream, "REF ");
 114         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 115         break;
 116
 117       case TYPE_CODE_BOOL:
 118         fprintf_filtered (stream, "BOOL");
 119         break;
 120
 121       case TYPE_CODE_ARRAY:
 122         range_type = TYPE_FIELD_TYPE (type, 0);
 123         index_type = TYPE_TARGET_TYPE (range_type);
 124         low_bound = TYPE_FIELD_BITPOS (range_type, 0);
 125         high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 126         fputs_filtered ("ARRAY (", stream);
 127         print_type_scalar (index_type, low_bound, stream);
 128         fputs_filtered (":", stream);
 129         print_type_scalar (index_type, high_bound, stream);
 130         fputs_filtered (") ", stream);
 131         chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 132         break;
 133
 134       case TYPE_CODE_SET:
 135         fputs_filtered ("POWERSET ", stream);
 136         chill_print_type (TYPE_FIELD_TYPE (type, 0), "", stream, show, level);
 137         break;
 138
 139       case TYPE_CODE_STRING:
 140         range_type = TYPE_FIELD_TYPE (type, 0);
 141         index_type = TYPE_TARGET_TYPE (range_type);
 142         high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 143         fputs_filtered ("CHAR (", stream);
 144         print_type_scalar (index_type, high_bound + 1, stream);
 145         fputs_filtered (")", stream);
 146         break;
 147
 148       case TYPE_CODE_MEMBER:
 149         fprintf_filtered (stream, "MEMBER ");
 150         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 151         break;
 152       case TYPE_CODE_REF:
 153         fprintf_filtered (stream, "/*LOC*/ ");
 154         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 155         break;
 156       case TYPE_CODE_FUNC:
 157         fprintf_filtered (stream, "PROC (?)");
 158         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 159         break;
 160
 161       case TYPE_CODE_STRUCT:
 162         fprintf_filtered (stream, "STRUCT ");
 163         if ((name = type_name_no_tag (type)) != NULL)
 164           {
 165             fputs_filtered (name, stream);
 166             fputs_filtered (" ", stream);
 167             wrap_here ("    ");
 168           }
 169         if (show < 0)
 170           {
 171             fprintf_filtered (stream, "(...)");
 172           }
 173         else
 174           {
 175             fprintf_filtered (stream, "(\n");
 176             if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 177               {
 178                 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 179                   {
 180                     fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 181                   }
 182                 else
 183                   {
 184                     fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 185                   }
 186               }
 187             else
 188               {
 189                 len = TYPE_NFIELDS (type);
 190                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 191                   {
 192                     struct type *field_type = TYPE_FIELD_TYPE (type, i);
 193                     QUIT;
 194                     print_spaces_filtered (level + 4, stream);
 195                     if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
 196                       { int j; /* variant number */
 197                         fputs_filtered ("CASE OF\n", stream);
 198                         for (j = 0; j < TYPE_NFIELDS (field_type); j++)
 199                           { int k; /* variant field index */
 200                             struct type *variant_type
 201                               = TYPE_FIELD_TYPE (field_type, j);
 202                             int var_len = TYPE_NFIELDS (variant_type);
 203                             print_spaces_filtered (level + 4, stream);
 204                             if (strcmp (TYPE_FIELD_NAME (field_type, j),
 205                                         "else") == 0)
 206                               fputs_filtered ("ELSE\n", stream);
 207                             else
 208                               fputs_filtered (":\n", stream);
 209                             if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
 210                               error ("variant record confusion");
 211                             for (k = 0; k < var_len; k++)
 212                               {
 213                                 print_spaces_filtered (level + 8, stream);
 214                                 chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
 215                                                   TYPE_FIELD_NAME (variant_type, k),
 216                                                   stream, show - 1, level + 8);
 217                                 if (k < (var_len - 1))
 218                                   fputs_filtered (",", stream);
 219                                 fputs_filtered ("\n", stream);
 220                               }
 221                           }
 222                         fputs_filtered ("ESAC\n", stream);
 223                       }
 224                     else
 225                       chill_print_type (field_type,
 226                                         TYPE_FIELD_NAME (type, i),
 227                                         stream, show - 1, level + 4);
 228                     if (i < (len - 1))
 229                       {
 230                         fputs_filtered (",", stream);
 231                       }
 232                     fputs_filtered ("\n", stream);
 233                   }
 234               }
 235             fprintfi_filtered (level, stream, ")");
 236           }
 237         break;
 238
 239       case TYPE_CODE_RANGE:
 240         if (TYPE_TARGET_TYPE (type))
 241           {
 242             chill_type_print_base (TYPE_TARGET_TYPE (type),
 243                                    stream, show, level);
 244             fputs_filtered (" (", stream);
 245             print_type_scalar (TYPE_TARGET_TYPE (type),
 246                                TYPE_FIELD_BITPOS (type, 0), stream);
 247             fputs_filtered (":", stream);
 248             print_type_scalar (TYPE_TARGET_TYPE (type),
 249                                TYPE_FIELD_BITPOS (type, 1), stream);
 250             fputs_filtered (")", stream);
 251           }
 252         else
 253           fprintf_filtered (stream, "RANGE? (%s : %d)",
 254                             TYPE_FIELD_BITPOS (type, 0),
 255                             TYPE_FIELD_BITPOS (type, 1));
 256         break;
 257
 258       case TYPE_CODE_VOID:
 259       case TYPE_CODE_UNDEF:
 260       case TYPE_CODE_ERROR:
 261       case TYPE_CODE_ENUM:
 262       case TYPE_CODE_UNION:
 263       case TYPE_CODE_METHOD:
 264         error ("missing language support in chill_type_print_base");
 265         break;
 266
 267       default:
 268
 269         /* Handle types not explicitly handled by the other cases,
 270            such as fundamental types.  For these, just print whatever
 271            the type name is, as recorded in the type itself.  If there
 272            is no type name, then complain. */
 273
 274         if (TYPE_NAME (type) != NULL)
 275           {
 276             fputs_filtered (TYPE_NAME (type), stream);
 277           }
 278         else
 279           {
 280             error ("Unrecognized type code (%d) in symbol table.",
 281                    TYPE_CODE (type));
 282           }
 283         break;
 284       }
 285 }