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