Just testing checkins.
[deliverable/binutils-gdb.git] / 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
35 #include <string.h>
36 #include <errno.h>
37
38 static void
39 chill_type_print_base PARAMS ((struct type *, FILE *, int, int));
40
41 void
42 chill_print_type (type, varstring, stream, show, level)
43 struct type *type;
44 char *varstring;
45 FILE *stream;
46 int show;
47 int level;
48 {
49 struct type *index_type;
50 struct type *range_type;
51 LONGEST low_bound;
52 LONGEST high_bound;
53
54 if (varstring != NULL && *varstring != '\0')
55 {
56 fputs_filtered (varstring, stream);
57 fputs_filtered (" ", stream);
58 }
59 switch (TYPE_CODE (type))
60 {
61 case TYPE_CODE_ARRAY:
62 range_type = TYPE_FIELD_TYPE (type, 0);
63 index_type = TYPE_TARGET_TYPE (range_type);
64 low_bound = TYPE_FIELD_BITPOS (range_type, 0);
65 high_bound = TYPE_FIELD_BITPOS (range_type, 1);
66 fputs_filtered ("array (", stream);
67 print_type_scalar (index_type, low_bound, stream);
68 fputs_filtered (":", stream);
69 print_type_scalar (index_type, high_bound, stream);
70 fputs_filtered (") ", stream);
71 chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
72 break;
73
74 case TYPE_CODE_STRING:
75 range_type = TYPE_FIELD_TYPE (type, 0);
76 index_type = TYPE_TARGET_TYPE (range_type);
77 high_bound = TYPE_FIELD_BITPOS (range_type, 1);
78 fputs_filtered ("CHAR (", stream);
79 print_type_scalar (index_type, high_bound + 1, stream);
80 fputs_filtered (")", stream);
81 break;
82
83 default:
84 chill_type_print_base (type, stream, show, level);
85 break;
86 }
87 }
88
89 /* Print the name of the type (or the ultimate pointer target,
90 function value or array element).
91
92 SHOW nonzero means don't print this type as just its name;
93 show its real definition even if it has a name.
94 SHOW zero means print just typename or tag if there is one
95 SHOW negative means abbreviate structure elements.
96 SHOW is decremented for printing of structure elements.
97
98 LEVEL is the depth to indent by.
99 We increase it for some recursive calls. */
100
101 static void
102 chill_type_print_base (type, stream, show, level)
103 struct type *type;
104 FILE *stream;
105 int show;
106 int level;
107 {
108 char *name;
109 register int len;
110 register int i;
111
112 QUIT;
113
114 wrap_here (" ");
115 if (type == NULL)
116 {
117 fputs_filtered ("<type unknown>", stream);
118 return;
119 }
120
121 /* When SHOW is zero or less, and there is a valid type name, then always
122 just print the type name directly from the type. */
123
124 if ((show <= 0) && (TYPE_NAME (type) != NULL))
125 {
126 fputs_filtered (TYPE_NAME (type), stream);
127 return;
128 }
129
130 switch (TYPE_CODE (type))
131 {
132 case TYPE_CODE_ARRAY:
133 case TYPE_CODE_PTR:
134 case TYPE_CODE_MEMBER:
135 case TYPE_CODE_REF:
136 case TYPE_CODE_FUNC:
137 chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
138 break;
139
140 case TYPE_CODE_STRUCT:
141 fprintf_filtered (stream, "STRUCT ");
142 if ((name = type_name_no_tag (type)) != NULL)
143 {
144 fputs_filtered (name, stream);
145 fputs_filtered (" ", stream);
146 wrap_here (" ");
147 }
148 if (show < 0)
149 {
150 fprintf_filtered (stream, "(...)");
151 }
152 else
153 {
154 check_stub_type (type);
155 fprintf_filtered (stream, "(\n");
156 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
157 {
158 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
159 {
160 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
161 }
162 else
163 {
164 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
165 }
166 }
167 else
168 {
169 len = TYPE_NFIELDS (type);
170 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
171 {
172 QUIT;
173 print_spaces_filtered (level + 4, stream);
174 chill_print_type (TYPE_FIELD_TYPE (type, i),
175 TYPE_FIELD_NAME (type, i),
176 stream, show - 1, level + 4);
177 if (i < (len - 1))
178 {
179 fputs_filtered (",", stream);
180 }
181 fputs_filtered ("\n", stream);
182 }
183 }
184 fprintfi_filtered (level, stream, ")");
185 }
186 break;
187
188 case TYPE_CODE_VOID:
189 case TYPE_CODE_UNDEF:
190 case TYPE_CODE_ERROR:
191 case TYPE_CODE_RANGE:
192 case TYPE_CODE_ENUM:
193 case TYPE_CODE_UNION:
194 case TYPE_CODE_METHOD:
195 error ("missing language support in chill_type_print_base");
196 break;
197
198 default:
199
200 /* Handle types not explicitly handled by the other cases,
201 such as fundamental types. For these, just print whatever
202 the type name is, as recorded in the type itself. If there
203 is no type name, then complain. */
204
205 if (TYPE_NAME (type) != NULL)
206 {
207 fputs_filtered (TYPE_NAME (type), stream);
208 }
209 else
210 {
211 error ("Unrecognized type code (%d) in symbol table.",
212 TYPE_CODE (type));
213 }
214 break;
215 }
216 }
This page took 0.033384 seconds and 4 git commands to generate.