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 *, FILE *, int, int));
  41
  42 void
  43 chill_print_type (type, varstring, stream, show, level)
  44      struct type *type;
  45      char *varstring;
  46      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      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   switch (TYPE_CODE (type))
 104     {
 105       case TYPE_CODE_PTR:
 106         if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
 107           {
 108             fprintf_filtered (stream, "PTR");
 109             break;
 110           }
 111         fprintf_filtered (stream, "REF ");
 112         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 113         break;
 114
 115       case TYPE_CODE_ARRAY:
 116         range_type = TYPE_FIELD_TYPE (type, 0);
 117         index_type = TYPE_TARGET_TYPE (range_type);
 118         low_bound = TYPE_FIELD_BITPOS (range_type, 0);
 119         high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 120         fputs_filtered ("ARRAY (", stream);
 121         print_type_scalar (index_type, low_bound, stream);
 122         fputs_filtered (":", stream);
 123         print_type_scalar (index_type, high_bound, stream);
 124         fputs_filtered (") ", stream);
 125         chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 126         break;
 127
 128       case TYPE_CODE_STRING:
 129         range_type = TYPE_FIELD_TYPE (type, 0);
 130         index_type = TYPE_TARGET_TYPE (range_type);
 131         high_bound = TYPE_FIELD_BITPOS (range_type, 1);
 132         fputs_filtered ("CHAR (", stream);
 133         print_type_scalar (index_type, high_bound + 1, stream);
 134         fputs_filtered (")", stream);
 135         break;
 136
 137       case TYPE_CODE_MEMBER:
 138         fprintf_filtered (stream, "MEMBER ");
 139         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 140         break;
 141       case TYPE_CODE_REF:
 142         fprintf_filtered (stream, "/*LOC*/ ");
 143         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 144         break;
 145       case TYPE_CODE_FUNC:
 146         fprintf_filtered (stream, "PROC (?)");
 147         chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 148         break;
 149
 150       case TYPE_CODE_STRUCT:
 151         fprintf_filtered (stream, "STRUCT ");
 152         if ((name = type_name_no_tag (type)) != NULL)
 153           {
 154             fputs_filtered (name, stream);
 155             fputs_filtered (" ", stream);
 156             wrap_here ("    ");
 157           }
 158         if (show < 0)
 159           {
 160             fprintf_filtered (stream, "(...)");
 161           }
 162         else
 163           {
 164             check_stub_type (type);
 165             fprintf_filtered (stream, "(\n");
 166             if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 167               {
 168                 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 169                   {
 170                     fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 171                   }
 172                 else
 173                   {
 174                     fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 175                   }
 176               }
 177             else
 178               {
 179                 len = TYPE_NFIELDS (type);
 180                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 181                   {
 182                     QUIT;
 183                     print_spaces_filtered (level + 4, stream);
 184                     chill_print_type (TYPE_FIELD_TYPE (type, i),
 185                                       TYPE_FIELD_NAME (type, i),
 186                                       stream, show - 1, level + 4);
 187                     if (i < (len - 1))
 188                       {
 189                         fputs_filtered (",", stream);
 190                       }
 191                     fputs_filtered ("\n", stream);
 192                   }
 193               }
 194             fprintfi_filtered (level, stream, ")");
 195           }
 196         break;
 197
 198       case TYPE_CODE_VOID:
 199       case TYPE_CODE_UNDEF:
 200       case TYPE_CODE_ERROR:
 201       case TYPE_CODE_RANGE:
 202       case TYPE_CODE_ENUM:
 203       case TYPE_CODE_UNION:
 204       case TYPE_CODE_METHOD:
 205         error ("missing language support in chill_type_print_base");
 206         break;
 207
 208       default:
 209
 210         /* Handle types not explicitly handled by the other cases,
 211            such as fundamental types.  For these, just print whatever
 212            the type name is, as recorded in the type itself.  If there
 213            is no type name, then complain. */
 214
 215         if (TYPE_NAME (type) != NULL)
 216           {
 217             fputs_filtered (TYPE_NAME (type), stream);
 218           }
 219         else
 220           {
 221             error ("Unrecognized type code (%d) in symbol table.",
 222                    TYPE_CODE (type));
 223           }
 224         break;
 225       }
 226 }