1 |
330 |
jeremybenn |
/* Support for printing C and C++ types for GDB, the GNU debugger.
|
2 |
|
|
Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
|
3 |
|
|
1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010
|
4 |
|
|
Free Software Foundation, Inc.
|
5 |
|
|
|
6 |
|
|
This file is part of GDB.
|
7 |
|
|
|
8 |
|
|
This program is free software; you can redistribute it and/or modify
|
9 |
|
|
it under the terms of the GNU General Public License as published by
|
10 |
|
|
the Free Software Foundation; either version 3 of the License, or
|
11 |
|
|
(at your option) any later version.
|
12 |
|
|
|
13 |
|
|
This program is distributed in the hope that it will be useful,
|
14 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
|
|
GNU General Public License for more details.
|
17 |
|
|
|
18 |
|
|
You should have received a copy of the GNU General Public License
|
19 |
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
20 |
|
|
|
21 |
|
|
#include "defs.h"
|
22 |
|
|
#include "gdb_obstack.h"
|
23 |
|
|
#include "bfd.h" /* Binary File Description */
|
24 |
|
|
#include "symtab.h"
|
25 |
|
|
#include "gdbtypes.h"
|
26 |
|
|
#include "expression.h"
|
27 |
|
|
#include "value.h"
|
28 |
|
|
#include "gdbcore.h"
|
29 |
|
|
#include "target.h"
|
30 |
|
|
#include "language.h"
|
31 |
|
|
#include "demangle.h"
|
32 |
|
|
#include "c-lang.h"
|
33 |
|
|
#include "typeprint.h"
|
34 |
|
|
#include "cp-abi.h"
|
35 |
|
|
#include "jv-lang.h"
|
36 |
|
|
|
37 |
|
|
#include "gdb_string.h"
|
38 |
|
|
#include <errno.h>
|
39 |
|
|
|
40 |
|
|
static void cp_type_print_method_args (struct type *mtype, char *prefix,
|
41 |
|
|
char *varstring, int staticp,
|
42 |
|
|
struct ui_file *stream);
|
43 |
|
|
|
44 |
|
|
static void cp_type_print_derivation_info (struct ui_file *, struct type *);
|
45 |
|
|
|
46 |
|
|
static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
|
47 |
|
|
int, int);
|
48 |
|
|
|
49 |
|
|
/* Print "const", "volatile", or address space modifiers. */
|
50 |
|
|
static void c_type_print_modifier (struct type *, struct ui_file *,
|
51 |
|
|
int, int);
|
52 |
|
|
|
53 |
|
|
|
54 |
|
|
|
55 |
|
|
|
56 |
|
|
/* LEVEL is the depth to indent lines by. */
|
57 |
|
|
|
58 |
|
|
void
|
59 |
|
|
c_print_type (struct type *type, const char *varstring, struct ui_file *stream,
|
60 |
|
|
int show, int level)
|
61 |
|
|
{
|
62 |
|
|
enum type_code code;
|
63 |
|
|
int demangled_args;
|
64 |
|
|
int need_post_space;
|
65 |
|
|
|
66 |
|
|
if (show > 0)
|
67 |
|
|
CHECK_TYPEDEF (type);
|
68 |
|
|
|
69 |
|
|
c_type_print_base (type, stream, show, level);
|
70 |
|
|
code = TYPE_CODE (type);
|
71 |
|
|
if ((varstring != NULL && *varstring != '\0')
|
72 |
|
|
/* Need a space if going to print stars or brackets;
|
73 |
|
|
but not if we will print just a type name. */
|
74 |
|
|
|| ((show > 0 || TYPE_NAME (type) == 0)
|
75 |
|
|
&& (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
|
76 |
|
|
|| code == TYPE_CODE_METHOD
|
77 |
|
|
|| code == TYPE_CODE_ARRAY
|
78 |
|
|
|| code == TYPE_CODE_MEMBERPTR
|
79 |
|
|
|| code == TYPE_CODE_METHODPTR
|
80 |
|
|
|| code == TYPE_CODE_REF)))
|
81 |
|
|
fputs_filtered (" ", stream);
|
82 |
|
|
need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
|
83 |
|
|
c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
|
84 |
|
|
|
85 |
|
|
if (varstring != NULL)
|
86 |
|
|
{
|
87 |
|
|
fputs_filtered (varstring, stream);
|
88 |
|
|
|
89 |
|
|
/* For demangled function names, we have the arglist as part of the name,
|
90 |
|
|
so don't print an additional pair of ()'s */
|
91 |
|
|
|
92 |
|
|
demangled_args = strchr (varstring, '(') != NULL;
|
93 |
|
|
c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
|
94 |
|
|
}
|
95 |
|
|
}
|
96 |
|
|
|
97 |
|
|
/* Print a typedef using C syntax. TYPE is the underlying type.
|
98 |
|
|
NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
|
99 |
|
|
which to print. */
|
100 |
|
|
|
101 |
|
|
void
|
102 |
|
|
c_print_typedef (struct type *type, struct symbol *new_symbol,
|
103 |
|
|
struct ui_file *stream)
|
104 |
|
|
{
|
105 |
|
|
CHECK_TYPEDEF (type);
|
106 |
|
|
fprintf_filtered (stream, "typedef ");
|
107 |
|
|
type_print (type, "", stream, 0);
|
108 |
|
|
if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
|
109 |
|
|
|| strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
|
110 |
|
|
SYMBOL_LINKAGE_NAME (new_symbol)) != 0
|
111 |
|
|
|| TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
|
112 |
|
|
fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
|
113 |
|
|
fprintf_filtered (stream, ";\n");
|
114 |
|
|
}
|
115 |
|
|
|
116 |
|
|
/* If TYPE is a derived type, then print out derivation information.
|
117 |
|
|
Print only the actual base classes of this type, not the base classes
|
118 |
|
|
of the base classes. I.E. for the derivation hierarchy:
|
119 |
|
|
|
120 |
|
|
class A { int a; };
|
121 |
|
|
class B : public A {int b; };
|
122 |
|
|
class C : public B {int c; };
|
123 |
|
|
|
124 |
|
|
Print the type of class C as:
|
125 |
|
|
|
126 |
|
|
class C : public B {
|
127 |
|
|
int c;
|
128 |
|
|
}
|
129 |
|
|
|
130 |
|
|
Not as the following (like gdb used to), which is not legal C++ syntax for
|
131 |
|
|
derived types and may be confused with the multiple inheritance form:
|
132 |
|
|
|
133 |
|
|
class C : public B : public A {
|
134 |
|
|
int c;
|
135 |
|
|
}
|
136 |
|
|
|
137 |
|
|
In general, gdb should try to print the types as closely as possible to
|
138 |
|
|
the form that they appear in the source code.
|
139 |
|
|
Note that in case of protected derivation gcc will not say 'protected'
|
140 |
|
|
but 'private'. The HP's aCC compiler emits specific information for
|
141 |
|
|
derivation via protected inheritance, so gdb can print it out */
|
142 |
|
|
|
143 |
|
|
static void
|
144 |
|
|
cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
|
145 |
|
|
{
|
146 |
|
|
char *name;
|
147 |
|
|
int i;
|
148 |
|
|
|
149 |
|
|
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
|
150 |
|
|
{
|
151 |
|
|
fputs_filtered (i == 0 ? ": " : ", ", stream);
|
152 |
|
|
fprintf_filtered (stream, "%s%s ",
|
153 |
|
|
BASETYPE_VIA_PUBLIC (type, i) ? "public"
|
154 |
|
|
: (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
|
155 |
|
|
BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
|
156 |
|
|
name = type_name_no_tag (TYPE_BASECLASS (type, i));
|
157 |
|
|
fprintf_filtered (stream, "%s", name ? name : "(null)");
|
158 |
|
|
}
|
159 |
|
|
if (i > 0)
|
160 |
|
|
{
|
161 |
|
|
fputs_filtered (" ", stream);
|
162 |
|
|
}
|
163 |
|
|
}
|
164 |
|
|
|
165 |
|
|
/* Print the C++ method arguments ARGS to the file STREAM. */
|
166 |
|
|
|
167 |
|
|
static void
|
168 |
|
|
cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
|
169 |
|
|
int staticp, struct ui_file *stream)
|
170 |
|
|
{
|
171 |
|
|
struct field *args = TYPE_FIELDS (mtype);
|
172 |
|
|
int nargs = TYPE_NFIELDS (mtype);
|
173 |
|
|
int varargs = TYPE_VARARGS (mtype);
|
174 |
|
|
int i;
|
175 |
|
|
|
176 |
|
|
fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
|
177 |
|
|
fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
|
178 |
|
|
fputs_filtered ("(", stream);
|
179 |
|
|
|
180 |
|
|
/* Skip the class variable. */
|
181 |
|
|
i = staticp ? 0 : 1;
|
182 |
|
|
if (nargs > i)
|
183 |
|
|
{
|
184 |
|
|
while (i < nargs)
|
185 |
|
|
{
|
186 |
|
|
type_print (args[i++].type, "", stream, 0);
|
187 |
|
|
|
188 |
|
|
if (i == nargs && varargs)
|
189 |
|
|
fprintf_filtered (stream, ", ...");
|
190 |
|
|
else if (i < nargs)
|
191 |
|
|
fprintf_filtered (stream, ", ");
|
192 |
|
|
}
|
193 |
|
|
}
|
194 |
|
|
else if (varargs)
|
195 |
|
|
fprintf_filtered (stream, "...");
|
196 |
|
|
else if (current_language->la_language == language_cplus)
|
197 |
|
|
fprintf_filtered (stream, "void");
|
198 |
|
|
|
199 |
|
|
fprintf_filtered (stream, ")");
|
200 |
|
|
|
201 |
|
|
/* For non-static methods, read qualifiers from the type of
|
202 |
|
|
THIS. */
|
203 |
|
|
if (!staticp)
|
204 |
|
|
{
|
205 |
|
|
struct type *domain;
|
206 |
|
|
|
207 |
|
|
gdb_assert (nargs > 0);
|
208 |
|
|
gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
|
209 |
|
|
domain = TYPE_TARGET_TYPE (args[0].type);
|
210 |
|
|
|
211 |
|
|
if (TYPE_CONST (domain))
|
212 |
|
|
fprintf_filtered (stream, " const");
|
213 |
|
|
|
214 |
|
|
if (TYPE_VOLATILE (domain))
|
215 |
|
|
fprintf_filtered (stream, " volatile");
|
216 |
|
|
}
|
217 |
|
|
}
|
218 |
|
|
|
219 |
|
|
|
220 |
|
|
/* Print any asterisks or open-parentheses needed before the
|
221 |
|
|
variable name (to describe its type).
|
222 |
|
|
|
223 |
|
|
On outermost call, pass 0 for PASSED_A_PTR.
|
224 |
|
|
On outermost call, SHOW > 0 means should ignore
|
225 |
|
|
any typename for TYPE and show its details.
|
226 |
|
|
SHOW is always zero on recursive calls.
|
227 |
|
|
|
228 |
|
|
NEED_POST_SPACE is non-zero when a space will be be needed
|
229 |
|
|
between a trailing qualifier and a field, variable, or function
|
230 |
|
|
name. */
|
231 |
|
|
|
232 |
|
|
void
|
233 |
|
|
c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
|
234 |
|
|
int show, int passed_a_ptr, int need_post_space)
|
235 |
|
|
{
|
236 |
|
|
char *name;
|
237 |
|
|
|
238 |
|
|
if (type == 0)
|
239 |
|
|
return;
|
240 |
|
|
|
241 |
|
|
if (TYPE_NAME (type) && show <= 0)
|
242 |
|
|
return;
|
243 |
|
|
|
244 |
|
|
QUIT;
|
245 |
|
|
|
246 |
|
|
switch (TYPE_CODE (type))
|
247 |
|
|
{
|
248 |
|
|
case TYPE_CODE_PTR:
|
249 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
|
250 |
|
|
fprintf_filtered (stream, "*");
|
251 |
|
|
c_type_print_modifier (type, stream, 1, need_post_space);
|
252 |
|
|
break;
|
253 |
|
|
|
254 |
|
|
case TYPE_CODE_MEMBERPTR:
|
255 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
|
256 |
|
|
name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
|
257 |
|
|
if (name)
|
258 |
|
|
fputs_filtered (name, stream);
|
259 |
|
|
else
|
260 |
|
|
c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
|
261 |
|
|
fprintf_filtered (stream, "::*");
|
262 |
|
|
break;
|
263 |
|
|
|
264 |
|
|
case TYPE_CODE_METHODPTR:
|
265 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
|
266 |
|
|
fprintf_filtered (stream, "(");
|
267 |
|
|
name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
|
268 |
|
|
if (name)
|
269 |
|
|
fputs_filtered (name, stream);
|
270 |
|
|
else
|
271 |
|
|
c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
|
272 |
|
|
fprintf_filtered (stream, "::*");
|
273 |
|
|
break;
|
274 |
|
|
|
275 |
|
|
case TYPE_CODE_REF:
|
276 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
|
277 |
|
|
fprintf_filtered (stream, "&");
|
278 |
|
|
c_type_print_modifier (type, stream, 1, need_post_space);
|
279 |
|
|
break;
|
280 |
|
|
|
281 |
|
|
case TYPE_CODE_METHOD:
|
282 |
|
|
case TYPE_CODE_FUNC:
|
283 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
|
284 |
|
|
if (passed_a_ptr)
|
285 |
|
|
fprintf_filtered (stream, "(");
|
286 |
|
|
break;
|
287 |
|
|
|
288 |
|
|
case TYPE_CODE_ARRAY:
|
289 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
|
290 |
|
|
if (passed_a_ptr)
|
291 |
|
|
fprintf_filtered (stream, "(");
|
292 |
|
|
break;
|
293 |
|
|
|
294 |
|
|
case TYPE_CODE_TYPEDEF:
|
295 |
|
|
c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
|
296 |
|
|
break;
|
297 |
|
|
|
298 |
|
|
case TYPE_CODE_UNDEF:
|
299 |
|
|
case TYPE_CODE_STRUCT:
|
300 |
|
|
case TYPE_CODE_UNION:
|
301 |
|
|
case TYPE_CODE_ENUM:
|
302 |
|
|
case TYPE_CODE_INT:
|
303 |
|
|
case TYPE_CODE_FLT:
|
304 |
|
|
case TYPE_CODE_VOID:
|
305 |
|
|
case TYPE_CODE_ERROR:
|
306 |
|
|
case TYPE_CODE_CHAR:
|
307 |
|
|
case TYPE_CODE_BOOL:
|
308 |
|
|
case TYPE_CODE_SET:
|
309 |
|
|
case TYPE_CODE_RANGE:
|
310 |
|
|
case TYPE_CODE_STRING:
|
311 |
|
|
case TYPE_CODE_BITSTRING:
|
312 |
|
|
case TYPE_CODE_COMPLEX:
|
313 |
|
|
case TYPE_CODE_NAMESPACE:
|
314 |
|
|
case TYPE_CODE_DECFLOAT:
|
315 |
|
|
/* These types need no prefix. They are listed here so that
|
316 |
|
|
gcc -Wall will reveal any types that haven't been handled. */
|
317 |
|
|
break;
|
318 |
|
|
default:
|
319 |
|
|
error (_("type not handled in c_type_print_varspec_prefix()"));
|
320 |
|
|
break;
|
321 |
|
|
}
|
322 |
|
|
}
|
323 |
|
|
|
324 |
|
|
/* Print out "const" and "volatile" attributes.
|
325 |
|
|
TYPE is a pointer to the type being printed out.
|
326 |
|
|
STREAM is the output destination.
|
327 |
|
|
NEED_SPACE = 1 indicates an initial white space is needed */
|
328 |
|
|
|
329 |
|
|
static void
|
330 |
|
|
c_type_print_modifier (struct type *type, struct ui_file *stream,
|
331 |
|
|
int need_pre_space, int need_post_space)
|
332 |
|
|
{
|
333 |
|
|
int did_print_modifier = 0;
|
334 |
|
|
const char *address_space_id;
|
335 |
|
|
|
336 |
|
|
/* We don't print `const' qualifiers for references --- since all
|
337 |
|
|
operators affect the thing referenced, not the reference itself,
|
338 |
|
|
every reference is `const'. */
|
339 |
|
|
if (TYPE_CONST (type)
|
340 |
|
|
&& TYPE_CODE (type) != TYPE_CODE_REF)
|
341 |
|
|
{
|
342 |
|
|
if (need_pre_space)
|
343 |
|
|
fprintf_filtered (stream, " ");
|
344 |
|
|
fprintf_filtered (stream, "const");
|
345 |
|
|
did_print_modifier = 1;
|
346 |
|
|
}
|
347 |
|
|
|
348 |
|
|
if (TYPE_VOLATILE (type))
|
349 |
|
|
{
|
350 |
|
|
if (did_print_modifier || need_pre_space)
|
351 |
|
|
fprintf_filtered (stream, " ");
|
352 |
|
|
fprintf_filtered (stream, "volatile");
|
353 |
|
|
did_print_modifier = 1;
|
354 |
|
|
}
|
355 |
|
|
|
356 |
|
|
address_space_id = address_space_int_to_name (get_type_arch (type),
|
357 |
|
|
TYPE_INSTANCE_FLAGS (type));
|
358 |
|
|
if (address_space_id)
|
359 |
|
|
{
|
360 |
|
|
if (did_print_modifier || need_pre_space)
|
361 |
|
|
fprintf_filtered (stream, " ");
|
362 |
|
|
fprintf_filtered (stream, "@%s", address_space_id);
|
363 |
|
|
did_print_modifier = 1;
|
364 |
|
|
}
|
365 |
|
|
|
366 |
|
|
if (did_print_modifier && need_post_space)
|
367 |
|
|
fprintf_filtered (stream, " ");
|
368 |
|
|
}
|
369 |
|
|
|
370 |
|
|
|
371 |
|
|
/* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
|
372 |
|
|
or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
|
373 |
|
|
in non-static methods, are displayed if SHOW_ARTIFICIAL is
|
374 |
|
|
non-zero. LANGUAGE is the language in which TYPE was defined. This is
|
375 |
|
|
a necessary evil since this code is used by the C, C++, and Java
|
376 |
|
|
backends. */
|
377 |
|
|
|
378 |
|
|
void
|
379 |
|
|
c_type_print_args (struct type *type, struct ui_file *stream,
|
380 |
|
|
int show_artificial, enum language language)
|
381 |
|
|
{
|
382 |
|
|
int i, len;
|
383 |
|
|
struct field *args;
|
384 |
|
|
int printed_any = 0;
|
385 |
|
|
|
386 |
|
|
fprintf_filtered (stream, "(");
|
387 |
|
|
args = TYPE_FIELDS (type);
|
388 |
|
|
len = TYPE_NFIELDS (type);
|
389 |
|
|
|
390 |
|
|
for (i = 0; i < TYPE_NFIELDS (type); i++)
|
391 |
|
|
{
|
392 |
|
|
if (TYPE_FIELD_ARTIFICIAL (type, i) && !show_artificial)
|
393 |
|
|
continue;
|
394 |
|
|
|
395 |
|
|
if (printed_any)
|
396 |
|
|
{
|
397 |
|
|
fprintf_filtered (stream, ", ");
|
398 |
|
|
wrap_here (" ");
|
399 |
|
|
}
|
400 |
|
|
|
401 |
|
|
if (language == language_java)
|
402 |
|
|
java_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
|
403 |
|
|
else
|
404 |
|
|
c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
|
405 |
|
|
printed_any = 1;
|
406 |
|
|
}
|
407 |
|
|
|
408 |
|
|
if (printed_any && TYPE_VARARGS (type))
|
409 |
|
|
{
|
410 |
|
|
/* Print out a trailing ellipsis for varargs functions. Ignore
|
411 |
|
|
TYPE_VARARGS if the function has no named arguments; that
|
412 |
|
|
represents unprototyped (K&R style) C functions. */
|
413 |
|
|
if (printed_any && TYPE_VARARGS (type))
|
414 |
|
|
{
|
415 |
|
|
fprintf_filtered (stream, ", ");
|
416 |
|
|
wrap_here (" ");
|
417 |
|
|
fprintf_filtered (stream, "...");
|
418 |
|
|
}
|
419 |
|
|
}
|
420 |
|
|
else if (!printed_any
|
421 |
|
|
&& ((TYPE_PROTOTYPED (type) && language != language_java)
|
422 |
|
|
|| language == language_cplus))
|
423 |
|
|
fprintf_filtered (stream, "void");
|
424 |
|
|
|
425 |
|
|
fprintf_filtered (stream, ")");
|
426 |
|
|
}
|
427 |
|
|
|
428 |
|
|
|
429 |
|
|
/* Return true iff the j'th overloading of the i'th method of TYPE
|
430 |
|
|
is a type conversion operator, like `operator int () { ... }'.
|
431 |
|
|
When listing a class's methods, we don't print the return type of
|
432 |
|
|
such operators. */
|
433 |
|
|
static int
|
434 |
|
|
is_type_conversion_operator (struct type *type, int i, int j)
|
435 |
|
|
{
|
436 |
|
|
/* I think the whole idea of recognizing type conversion operators
|
437 |
|
|
by their name is pretty terrible. But I don't think our present
|
438 |
|
|
data structure gives us any other way to tell. If you know of
|
439 |
|
|
some other way, feel free to rewrite this function. */
|
440 |
|
|
char *name = TYPE_FN_FIELDLIST_NAME (type, i);
|
441 |
|
|
|
442 |
|
|
if (strncmp (name, "operator", 8) != 0)
|
443 |
|
|
return 0;
|
444 |
|
|
|
445 |
|
|
name += 8;
|
446 |
|
|
if (! strchr (" \t\f\n\r", *name))
|
447 |
|
|
return 0;
|
448 |
|
|
|
449 |
|
|
while (strchr (" \t\f\n\r", *name))
|
450 |
|
|
name++;
|
451 |
|
|
|
452 |
|
|
if (!('a' <= *name && *name <= 'z')
|
453 |
|
|
&& !('A' <= *name && *name <= 'Z')
|
454 |
|
|
&& *name != '_')
|
455 |
|
|
/* If this doesn't look like the start of an identifier, then it
|
456 |
|
|
isn't a type conversion operator. */
|
457 |
|
|
return 0;
|
458 |
|
|
else if (strncmp (name, "new", 3) == 0)
|
459 |
|
|
name += 3;
|
460 |
|
|
else if (strncmp (name, "delete", 6) == 0)
|
461 |
|
|
name += 6;
|
462 |
|
|
else
|
463 |
|
|
/* If it doesn't look like new or delete, it's a type conversion
|
464 |
|
|
operator. */
|
465 |
|
|
return 1;
|
466 |
|
|
|
467 |
|
|
/* Is that really the end of the name? */
|
468 |
|
|
if (('a' <= *name && *name <= 'z')
|
469 |
|
|
|| ('A' <= *name && *name <= 'Z')
|
470 |
|
|
|| ('0' <= *name && *name <= '9')
|
471 |
|
|
|| *name == '_')
|
472 |
|
|
/* No, so the identifier following "operator" must be a type name,
|
473 |
|
|
and this is a type conversion operator. */
|
474 |
|
|
return 1;
|
475 |
|
|
|
476 |
|
|
/* That was indeed the end of the name, so it was `operator new' or
|
477 |
|
|
`operator delete', neither of which are type conversion operators. */
|
478 |
|
|
return 0;
|
479 |
|
|
}
|
480 |
|
|
|
481 |
|
|
|
482 |
|
|
/* Given a C++ qualified identifier QID, strip off the qualifiers,
|
483 |
|
|
yielding the unqualified name. The return value is a pointer into
|
484 |
|
|
the original string.
|
485 |
|
|
|
486 |
|
|
It's a pity we don't have this information in some more structured
|
487 |
|
|
form. Even the author of this function feels that writing little
|
488 |
|
|
parsers like this everywhere is stupid. */
|
489 |
|
|
static char *
|
490 |
|
|
remove_qualifiers (char *qid)
|
491 |
|
|
{
|
492 |
|
|
int quoted = 0; /* zero if we're not in quotes;
|
493 |
|
|
'"' if we're in a double-quoted string;
|
494 |
|
|
'\'' if we're in a single-quoted string. */
|
495 |
|
|
int depth = 0; /* number of unclosed parens we've seen */
|
496 |
|
|
char *parenstack = (char *) alloca (strlen (qid));
|
497 |
|
|
char *scan;
|
498 |
|
|
char *last = 0; /* The character after the rightmost
|
499 |
|
|
`::' token we've seen so far. */
|
500 |
|
|
|
501 |
|
|
for (scan = qid; *scan; scan++)
|
502 |
|
|
{
|
503 |
|
|
if (quoted)
|
504 |
|
|
{
|
505 |
|
|
if (*scan == quoted)
|
506 |
|
|
quoted = 0;
|
507 |
|
|
else if (*scan == '\\' && *(scan + 1))
|
508 |
|
|
scan++;
|
509 |
|
|
}
|
510 |
|
|
else if (scan[0] == ':' && scan[1] == ':')
|
511 |
|
|
{
|
512 |
|
|
/* If we're inside parenthesis (i.e., an argument list) or
|
513 |
|
|
angle brackets (i.e., a list of template arguments), then
|
514 |
|
|
we don't record the position of this :: token, since it's
|
515 |
|
|
not relevant to the top-level structure we're trying
|
516 |
|
|
to operate on. */
|
517 |
|
|
if (depth == 0)
|
518 |
|
|
{
|
519 |
|
|
last = scan + 2;
|
520 |
|
|
scan++;
|
521 |
|
|
}
|
522 |
|
|
}
|
523 |
|
|
else if (*scan == '"' || *scan == '\'')
|
524 |
|
|
quoted = *scan;
|
525 |
|
|
else if (*scan == '(')
|
526 |
|
|
parenstack[depth++] = ')';
|
527 |
|
|
else if (*scan == '[')
|
528 |
|
|
parenstack[depth++] = ']';
|
529 |
|
|
/* We're going to treat <> as a pair of matching characters,
|
530 |
|
|
since we're more likely to see those in template id's than
|
531 |
|
|
real less-than characters. What a crock. */
|
532 |
|
|
else if (*scan == '<')
|
533 |
|
|
parenstack[depth++] = '>';
|
534 |
|
|
else if (*scan == ')' || *scan == ']' || *scan == '>')
|
535 |
|
|
{
|
536 |
|
|
if (depth > 0 && parenstack[depth - 1] == *scan)
|
537 |
|
|
depth--;
|
538 |
|
|
else
|
539 |
|
|
{
|
540 |
|
|
/* We're going to do a little error recovery here. If we
|
541 |
|
|
don't find a match for *scan on the paren stack, but
|
542 |
|
|
there is something lower on the stack that does match, we
|
543 |
|
|
pop the stack to that point. */
|
544 |
|
|
int i;
|
545 |
|
|
|
546 |
|
|
for (i = depth - 1; i >= 0; i--)
|
547 |
|
|
if (parenstack[i] == *scan)
|
548 |
|
|
{
|
549 |
|
|
depth = i;
|
550 |
|
|
break;
|
551 |
|
|
}
|
552 |
|
|
}
|
553 |
|
|
}
|
554 |
|
|
}
|
555 |
|
|
|
556 |
|
|
if (last)
|
557 |
|
|
return last;
|
558 |
|
|
else
|
559 |
|
|
/* We didn't find any :: tokens at the top level, so declare the
|
560 |
|
|
whole thing an unqualified identifier. */
|
561 |
|
|
return qid;
|
562 |
|
|
}
|
563 |
|
|
|
564 |
|
|
|
565 |
|
|
/* Print any array sizes, function arguments or close parentheses
|
566 |
|
|
needed after the variable name (to describe its type).
|
567 |
|
|
Args work like c_type_print_varspec_prefix. */
|
568 |
|
|
|
569 |
|
|
void
|
570 |
|
|
c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
|
571 |
|
|
int show, int passed_a_ptr, int demangled_args)
|
572 |
|
|
{
|
573 |
|
|
if (type == 0)
|
574 |
|
|
return;
|
575 |
|
|
|
576 |
|
|
if (TYPE_NAME (type) && show <= 0)
|
577 |
|
|
return;
|
578 |
|
|
|
579 |
|
|
QUIT;
|
580 |
|
|
|
581 |
|
|
switch (TYPE_CODE (type))
|
582 |
|
|
{
|
583 |
|
|
case TYPE_CODE_ARRAY:
|
584 |
|
|
if (passed_a_ptr)
|
585 |
|
|
fprintf_filtered (stream, ")");
|
586 |
|
|
|
587 |
|
|
fprintf_filtered (stream, "[");
|
588 |
|
|
if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
|
589 |
|
|
&& !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
|
590 |
|
|
fprintf_filtered (stream, "%d",
|
591 |
|
|
(TYPE_LENGTH (type)
|
592 |
|
|
/ TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
|
593 |
|
|
fprintf_filtered (stream, "]");
|
594 |
|
|
|
595 |
|
|
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
|
596 |
|
|
0, 0);
|
597 |
|
|
break;
|
598 |
|
|
|
599 |
|
|
case TYPE_CODE_MEMBERPTR:
|
600 |
|
|
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
|
601 |
|
|
0, 0);
|
602 |
|
|
break;
|
603 |
|
|
|
604 |
|
|
case TYPE_CODE_METHODPTR:
|
605 |
|
|
fprintf_filtered (stream, ")");
|
606 |
|
|
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
|
607 |
|
|
0, 0);
|
608 |
|
|
break;
|
609 |
|
|
|
610 |
|
|
case TYPE_CODE_PTR:
|
611 |
|
|
case TYPE_CODE_REF:
|
612 |
|
|
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
|
613 |
|
|
1, 0);
|
614 |
|
|
break;
|
615 |
|
|
|
616 |
|
|
case TYPE_CODE_METHOD:
|
617 |
|
|
case TYPE_CODE_FUNC:
|
618 |
|
|
if (passed_a_ptr)
|
619 |
|
|
fprintf_filtered (stream, ")");
|
620 |
|
|
if (!demangled_args)
|
621 |
|
|
c_type_print_args (type, stream, 1, current_language->la_language);
|
622 |
|
|
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
|
623 |
|
|
passed_a_ptr, 0);
|
624 |
|
|
break;
|
625 |
|
|
|
626 |
|
|
case TYPE_CODE_TYPEDEF:
|
627 |
|
|
c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
|
628 |
|
|
passed_a_ptr, 0);
|
629 |
|
|
break;
|
630 |
|
|
|
631 |
|
|
case TYPE_CODE_UNDEF:
|
632 |
|
|
case TYPE_CODE_STRUCT:
|
633 |
|
|
case TYPE_CODE_UNION:
|
634 |
|
|
case TYPE_CODE_ENUM:
|
635 |
|
|
case TYPE_CODE_INT:
|
636 |
|
|
case TYPE_CODE_FLT:
|
637 |
|
|
case TYPE_CODE_VOID:
|
638 |
|
|
case TYPE_CODE_ERROR:
|
639 |
|
|
case TYPE_CODE_CHAR:
|
640 |
|
|
case TYPE_CODE_BOOL:
|
641 |
|
|
case TYPE_CODE_SET:
|
642 |
|
|
case TYPE_CODE_RANGE:
|
643 |
|
|
case TYPE_CODE_STRING:
|
644 |
|
|
case TYPE_CODE_BITSTRING:
|
645 |
|
|
case TYPE_CODE_COMPLEX:
|
646 |
|
|
case TYPE_CODE_NAMESPACE:
|
647 |
|
|
case TYPE_CODE_DECFLOAT:
|
648 |
|
|
/* These types do not need a suffix. They are listed so that
|
649 |
|
|
gcc -Wall will report types that may not have been considered. */
|
650 |
|
|
break;
|
651 |
|
|
default:
|
652 |
|
|
error (_("type not handled in c_type_print_varspec_suffix()"));
|
653 |
|
|
break;
|
654 |
|
|
}
|
655 |
|
|
}
|
656 |
|
|
|
657 |
|
|
/* Print the name of the type (or the ultimate pointer target,
|
658 |
|
|
function value or array element), or the description of a
|
659 |
|
|
structure or union.
|
660 |
|
|
|
661 |
|
|
SHOW positive means print details about the type (e.g. enum values),
|
662 |
|
|
and print structure elements passing SHOW - 1 for show.
|
663 |
|
|
SHOW negative means just print the type name or struct tag if there is one.
|
664 |
|
|
If there is no name, print something sensible but concise like
|
665 |
|
|
"struct {...}".
|
666 |
|
|
SHOW zero means just print the type name or struct tag if there is one.
|
667 |
|
|
If there is no name, print something sensible but not as concise like
|
668 |
|
|
"struct {int x; int y;}".
|
669 |
|
|
|
670 |
|
|
LEVEL is the number of spaces to indent by.
|
671 |
|
|
We increase it for some recursive calls. */
|
672 |
|
|
|
673 |
|
|
void
|
674 |
|
|
c_type_print_base (struct type *type, struct ui_file *stream, int show,
|
675 |
|
|
int level)
|
676 |
|
|
{
|
677 |
|
|
int i;
|
678 |
|
|
int len, real_len;
|
679 |
|
|
int lastval;
|
680 |
|
|
char *mangled_name;
|
681 |
|
|
char *demangled_name;
|
682 |
|
|
char *demangled_no_static;
|
683 |
|
|
enum
|
684 |
|
|
{
|
685 |
|
|
s_none, s_public, s_private, s_protected
|
686 |
|
|
}
|
687 |
|
|
section_type;
|
688 |
|
|
int need_access_label = 0;
|
689 |
|
|
int j, len2;
|
690 |
|
|
|
691 |
|
|
QUIT;
|
692 |
|
|
|
693 |
|
|
wrap_here (" ");
|
694 |
|
|
if (type == NULL)
|
695 |
|
|
{
|
696 |
|
|
fputs_filtered (_("<type unknown>"), stream);
|
697 |
|
|
return;
|
698 |
|
|
}
|
699 |
|
|
|
700 |
|
|
/* When SHOW is zero or less, and there is a valid type name, then always
|
701 |
|
|
just print the type name directly from the type. */
|
702 |
|
|
/* If we have "typedef struct foo {. . .} bar;" do we want to print it
|
703 |
|
|
as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
|
704 |
|
|
to expect things like "class5 *foo" rather than "struct class5 *foo". */
|
705 |
|
|
|
706 |
|
|
if (show <= 0
|
707 |
|
|
&& TYPE_NAME (type) != NULL)
|
708 |
|
|
{
|
709 |
|
|
c_type_print_modifier (type, stream, 0, 1);
|
710 |
|
|
fputs_filtered (TYPE_NAME (type), stream);
|
711 |
|
|
return;
|
712 |
|
|
}
|
713 |
|
|
|
714 |
|
|
CHECK_TYPEDEF (type);
|
715 |
|
|
|
716 |
|
|
switch (TYPE_CODE (type))
|
717 |
|
|
{
|
718 |
|
|
case TYPE_CODE_TYPEDEF:
|
719 |
|
|
case TYPE_CODE_ARRAY:
|
720 |
|
|
case TYPE_CODE_PTR:
|
721 |
|
|
case TYPE_CODE_MEMBERPTR:
|
722 |
|
|
case TYPE_CODE_REF:
|
723 |
|
|
case TYPE_CODE_FUNC:
|
724 |
|
|
case TYPE_CODE_METHOD:
|
725 |
|
|
case TYPE_CODE_METHODPTR:
|
726 |
|
|
c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
|
727 |
|
|
break;
|
728 |
|
|
|
729 |
|
|
case TYPE_CODE_STRUCT:
|
730 |
|
|
c_type_print_modifier (type, stream, 0, 1);
|
731 |
|
|
if (TYPE_DECLARED_CLASS (type))
|
732 |
|
|
fprintf_filtered (stream, "class ");
|
733 |
|
|
else
|
734 |
|
|
fprintf_filtered (stream, "struct ");
|
735 |
|
|
goto struct_union;
|
736 |
|
|
|
737 |
|
|
case TYPE_CODE_UNION:
|
738 |
|
|
c_type_print_modifier (type, stream, 0, 1);
|
739 |
|
|
fprintf_filtered (stream, "union ");
|
740 |
|
|
|
741 |
|
|
struct_union:
|
742 |
|
|
|
743 |
|
|
/* Print the tag if it exists.
|
744 |
|
|
* The HP aCC compiler emits
|
745 |
|
|
* a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
|
746 |
|
|
* tag for unnamed struct/union/enum's, which we don't
|
747 |
|
|
* want to print.
|
748 |
|
|
*/
|
749 |
|
|
if (TYPE_TAG_NAME (type) != NULL
|
750 |
|
|
&& strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
|
751 |
|
|
{
|
752 |
|
|
fputs_filtered (TYPE_TAG_NAME (type), stream);
|
753 |
|
|
if (show > 0)
|
754 |
|
|
fputs_filtered (" ", stream);
|
755 |
|
|
}
|
756 |
|
|
wrap_here (" ");
|
757 |
|
|
if (show < 0)
|
758 |
|
|
{
|
759 |
|
|
/* If we just printed a tag name, no need to print anything else. */
|
760 |
|
|
if (TYPE_TAG_NAME (type) == NULL)
|
761 |
|
|
fprintf_filtered (stream, "{...}");
|
762 |
|
|
}
|
763 |
|
|
else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
|
764 |
|
|
{
|
765 |
|
|
struct type *basetype;
|
766 |
|
|
int vptr_fieldno;
|
767 |
|
|
|
768 |
|
|
cp_type_print_derivation_info (stream, type);
|
769 |
|
|
|
770 |
|
|
fprintf_filtered (stream, "{\n");
|
771 |
|
|
if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
|
772 |
|
|
&& TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
|
773 |
|
|
{
|
774 |
|
|
if (TYPE_STUB (type))
|
775 |
|
|
fprintfi_filtered (level + 4, stream, _("<incomplete type>\n"));
|
776 |
|
|
else
|
777 |
|
|
fprintfi_filtered (level + 4, stream, _("<no data fields>\n"));
|
778 |
|
|
}
|
779 |
|
|
|
780 |
|
|
/* Start off with no specific section type, so we can print
|
781 |
|
|
one for the first field we find, and use that section type
|
782 |
|
|
thereafter until we find another type. */
|
783 |
|
|
|
784 |
|
|
section_type = s_none;
|
785 |
|
|
|
786 |
|
|
/* For a class, if all members are private, there's no need
|
787 |
|
|
for a "private:" label; similarly, for a struct or union
|
788 |
|
|
masquerading as a class, if all members are public, there's
|
789 |
|
|
no need for a "public:" label. */
|
790 |
|
|
|
791 |
|
|
if (TYPE_DECLARED_CLASS (type))
|
792 |
|
|
{
|
793 |
|
|
QUIT;
|
794 |
|
|
len = TYPE_NFIELDS (type);
|
795 |
|
|
for (i = TYPE_N_BASECLASSES (type); i < len; i++)
|
796 |
|
|
if (!TYPE_FIELD_PRIVATE (type, i))
|
797 |
|
|
{
|
798 |
|
|
need_access_label = 1;
|
799 |
|
|
break;
|
800 |
|
|
}
|
801 |
|
|
QUIT;
|
802 |
|
|
if (!need_access_label)
|
803 |
|
|
{
|
804 |
|
|
len2 = TYPE_NFN_FIELDS (type);
|
805 |
|
|
for (j = 0; j < len2; j++)
|
806 |
|
|
{
|
807 |
|
|
len = TYPE_FN_FIELDLIST_LENGTH (type, j);
|
808 |
|
|
for (i = 0; i < len; i++)
|
809 |
|
|
if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
|
810 |
|
|
{
|
811 |
|
|
need_access_label = 1;
|
812 |
|
|
break;
|
813 |
|
|
}
|
814 |
|
|
if (need_access_label)
|
815 |
|
|
break;
|
816 |
|
|
}
|
817 |
|
|
}
|
818 |
|
|
}
|
819 |
|
|
else
|
820 |
|
|
{
|
821 |
|
|
QUIT;
|
822 |
|
|
len = TYPE_NFIELDS (type);
|
823 |
|
|
for (i = TYPE_N_BASECLASSES (type); i < len; i++)
|
824 |
|
|
if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
|
825 |
|
|
{
|
826 |
|
|
need_access_label = 1;
|
827 |
|
|
break;
|
828 |
|
|
}
|
829 |
|
|
QUIT;
|
830 |
|
|
if (!need_access_label)
|
831 |
|
|
{
|
832 |
|
|
len2 = TYPE_NFN_FIELDS (type);
|
833 |
|
|
for (j = 0; j < len2; j++)
|
834 |
|
|
{
|
835 |
|
|
QUIT;
|
836 |
|
|
len = TYPE_FN_FIELDLIST_LENGTH (type, j);
|
837 |
|
|
for (i = 0; i < len; i++)
|
838 |
|
|
if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i)
|
839 |
|
|
|| TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
|
840 |
|
|
{
|
841 |
|
|
need_access_label = 1;
|
842 |
|
|
break;
|
843 |
|
|
}
|
844 |
|
|
if (need_access_label)
|
845 |
|
|
break;
|
846 |
|
|
}
|
847 |
|
|
}
|
848 |
|
|
}
|
849 |
|
|
|
850 |
|
|
/* If there is a base class for this type,
|
851 |
|
|
do not print the field that it occupies. */
|
852 |
|
|
|
853 |
|
|
len = TYPE_NFIELDS (type);
|
854 |
|
|
vptr_fieldno = get_vptr_fieldno (type, &basetype);
|
855 |
|
|
for (i = TYPE_N_BASECLASSES (type); i < len; i++)
|
856 |
|
|
{
|
857 |
|
|
QUIT;
|
858 |
|
|
|
859 |
|
|
/* If we have a virtual table pointer, omit it. Even if
|
860 |
|
|
virtual table pointers are not specifically marked in
|
861 |
|
|
the debug info, they should be artificial. */
|
862 |
|
|
if ((i == vptr_fieldno && type == basetype)
|
863 |
|
|
|| TYPE_FIELD_ARTIFICIAL (type, i))
|
864 |
|
|
continue;
|
865 |
|
|
|
866 |
|
|
if (need_access_label)
|
867 |
|
|
{
|
868 |
|
|
if (TYPE_FIELD_PROTECTED (type, i))
|
869 |
|
|
{
|
870 |
|
|
if (section_type != s_protected)
|
871 |
|
|
{
|
872 |
|
|
section_type = s_protected;
|
873 |
|
|
fprintfi_filtered (level + 2, stream,
|
874 |
|
|
"protected:\n");
|
875 |
|
|
}
|
876 |
|
|
}
|
877 |
|
|
else if (TYPE_FIELD_PRIVATE (type, i))
|
878 |
|
|
{
|
879 |
|
|
if (section_type != s_private)
|
880 |
|
|
{
|
881 |
|
|
section_type = s_private;
|
882 |
|
|
fprintfi_filtered (level + 2, stream, "private:\n");
|
883 |
|
|
}
|
884 |
|
|
}
|
885 |
|
|
else
|
886 |
|
|
{
|
887 |
|
|
if (section_type != s_public)
|
888 |
|
|
{
|
889 |
|
|
section_type = s_public;
|
890 |
|
|
fprintfi_filtered (level + 2, stream, "public:\n");
|
891 |
|
|
}
|
892 |
|
|
}
|
893 |
|
|
}
|
894 |
|
|
|
895 |
|
|
print_spaces_filtered (level + 4, stream);
|
896 |
|
|
if (field_is_static (&TYPE_FIELD (type, i)))
|
897 |
|
|
fprintf_filtered (stream, "static ");
|
898 |
|
|
c_print_type (TYPE_FIELD_TYPE (type, i),
|
899 |
|
|
TYPE_FIELD_NAME (type, i),
|
900 |
|
|
stream, show - 1, level + 4);
|
901 |
|
|
if (!field_is_static (&TYPE_FIELD (type, i))
|
902 |
|
|
&& TYPE_FIELD_PACKED (type, i))
|
903 |
|
|
{
|
904 |
|
|
/* It is a bitfield. This code does not attempt
|
905 |
|
|
to look at the bitpos and reconstruct filler,
|
906 |
|
|
unnamed fields. This would lead to misleading
|
907 |
|
|
results if the compiler does not put out fields
|
908 |
|
|
for such things (I don't know what it does). */
|
909 |
|
|
fprintf_filtered (stream, " : %d",
|
910 |
|
|
TYPE_FIELD_BITSIZE (type, i));
|
911 |
|
|
}
|
912 |
|
|
fprintf_filtered (stream, ";\n");
|
913 |
|
|
}
|
914 |
|
|
|
915 |
|
|
/* If there are both fields and methods, put a blank line
|
916 |
|
|
between them. Make sure to count only method that we will
|
917 |
|
|
display; artificial methods will be hidden. */
|
918 |
|
|
len = TYPE_NFN_FIELDS (type);
|
919 |
|
|
real_len = 0;
|
920 |
|
|
for (i = 0; i < len; i++)
|
921 |
|
|
{
|
922 |
|
|
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
|
923 |
|
|
int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
|
924 |
|
|
int j;
|
925 |
|
|
|
926 |
|
|
for (j = 0; j < len2; j++)
|
927 |
|
|
if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
|
928 |
|
|
real_len++;
|
929 |
|
|
}
|
930 |
|
|
if (real_len > 0 && section_type != s_none)
|
931 |
|
|
fprintf_filtered (stream, "\n");
|
932 |
|
|
|
933 |
|
|
/* C++: print out the methods */
|
934 |
|
|
for (i = 0; i < len; i++)
|
935 |
|
|
{
|
936 |
|
|
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
|
937 |
|
|
int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
|
938 |
|
|
char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
|
939 |
|
|
char *name = type_name_no_tag (type);
|
940 |
|
|
int is_constructor = name && strcmp (method_name, name) == 0;
|
941 |
|
|
|
942 |
|
|
for (j = 0; j < len2; j++)
|
943 |
|
|
{
|
944 |
|
|
char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
|
945 |
|
|
int is_full_physname_constructor =
|
946 |
|
|
is_constructor_name (physname)
|
947 |
|
|
|| is_destructor_name (physname)
|
948 |
|
|
|| method_name[0] == '~';
|
949 |
|
|
|
950 |
|
|
/* Do not print out artificial methods. */
|
951 |
|
|
if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
|
952 |
|
|
continue;
|
953 |
|
|
|
954 |
|
|
QUIT;
|
955 |
|
|
if (TYPE_FN_FIELD_PROTECTED (f, j))
|
956 |
|
|
{
|
957 |
|
|
if (section_type != s_protected)
|
958 |
|
|
{
|
959 |
|
|
section_type = s_protected;
|
960 |
|
|
fprintfi_filtered (level + 2, stream,
|
961 |
|
|
"protected:\n");
|
962 |
|
|
}
|
963 |
|
|
}
|
964 |
|
|
else if (TYPE_FN_FIELD_PRIVATE (f, j))
|
965 |
|
|
{
|
966 |
|
|
if (section_type != s_private)
|
967 |
|
|
{
|
968 |
|
|
section_type = s_private;
|
969 |
|
|
fprintfi_filtered (level + 2, stream, "private:\n");
|
970 |
|
|
}
|
971 |
|
|
}
|
972 |
|
|
else
|
973 |
|
|
{
|
974 |
|
|
if (section_type != s_public)
|
975 |
|
|
{
|
976 |
|
|
section_type = s_public;
|
977 |
|
|
fprintfi_filtered (level + 2, stream, "public:\n");
|
978 |
|
|
}
|
979 |
|
|
}
|
980 |
|
|
|
981 |
|
|
print_spaces_filtered (level + 4, stream);
|
982 |
|
|
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
|
983 |
|
|
fprintf_filtered (stream, "virtual ");
|
984 |
|
|
else if (TYPE_FN_FIELD_STATIC_P (f, j))
|
985 |
|
|
fprintf_filtered (stream, "static ");
|
986 |
|
|
if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
|
987 |
|
|
{
|
988 |
|
|
/* Keep GDB from crashing here. */
|
989 |
|
|
fprintf_filtered (stream, _("<undefined type> %s;\n"),
|
990 |
|
|
TYPE_FN_FIELD_PHYSNAME (f, j));
|
991 |
|
|
break;
|
992 |
|
|
}
|
993 |
|
|
else if (!is_constructor /* constructors don't have declared types */
|
994 |
|
|
&& !is_full_physname_constructor /* " " */
|
995 |
|
|
&& !is_type_conversion_operator (type, i, j))
|
996 |
|
|
{
|
997 |
|
|
type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
|
998 |
|
|
"", stream, -1);
|
999 |
|
|
fputs_filtered (" ", stream);
|
1000 |
|
|
}
|
1001 |
|
|
if (TYPE_FN_FIELD_STUB (f, j))
|
1002 |
|
|
/* Build something we can demangle. */
|
1003 |
|
|
mangled_name = gdb_mangle_name (type, i, j);
|
1004 |
|
|
else
|
1005 |
|
|
mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
|
1006 |
|
|
|
1007 |
|
|
demangled_name =
|
1008 |
|
|
cplus_demangle (mangled_name,
|
1009 |
|
|
DMGL_ANSI | DMGL_PARAMS);
|
1010 |
|
|
if (demangled_name == NULL)
|
1011 |
|
|
{
|
1012 |
|
|
/* in some cases (for instance with the HP demangling),
|
1013 |
|
|
if a function has more than 10 arguments,
|
1014 |
|
|
the demangling will fail.
|
1015 |
|
|
Let's try to reconstruct the function signature from
|
1016 |
|
|
the symbol information */
|
1017 |
|
|
if (!TYPE_FN_FIELD_STUB (f, j))
|
1018 |
|
|
{
|
1019 |
|
|
int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
|
1020 |
|
|
struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
|
1021 |
|
|
|
1022 |
|
|
cp_type_print_method_args (mtype,
|
1023 |
|
|
"",
|
1024 |
|
|
method_name,
|
1025 |
|
|
staticp,
|
1026 |
|
|
stream);
|
1027 |
|
|
}
|
1028 |
|
|
else
|
1029 |
|
|
fprintf_filtered (stream, _("<badly mangled name '%s'>"),
|
1030 |
|
|
mangled_name);
|
1031 |
|
|
}
|
1032 |
|
|
else
|
1033 |
|
|
{
|
1034 |
|
|
char *p;
|
1035 |
|
|
char *demangled_no_class
|
1036 |
|
|
= remove_qualifiers (demangled_name);
|
1037 |
|
|
|
1038 |
|
|
/* get rid of the `static' appended by the demangler */
|
1039 |
|
|
p = strstr (demangled_no_class, " static");
|
1040 |
|
|
if (p != NULL)
|
1041 |
|
|
{
|
1042 |
|
|
int length = p - demangled_no_class;
|
1043 |
|
|
|
1044 |
|
|
demangled_no_static = (char *) xmalloc (length + 1);
|
1045 |
|
|
strncpy (demangled_no_static, demangled_no_class, length);
|
1046 |
|
|
*(demangled_no_static + length) = '\0';
|
1047 |
|
|
fputs_filtered (demangled_no_static, stream);
|
1048 |
|
|
xfree (demangled_no_static);
|
1049 |
|
|
}
|
1050 |
|
|
else
|
1051 |
|
|
fputs_filtered (demangled_no_class, stream);
|
1052 |
|
|
xfree (demangled_name);
|
1053 |
|
|
}
|
1054 |
|
|
|
1055 |
|
|
if (TYPE_FN_FIELD_STUB (f, j))
|
1056 |
|
|
xfree (mangled_name);
|
1057 |
|
|
|
1058 |
|
|
fprintf_filtered (stream, ";\n");
|
1059 |
|
|
}
|
1060 |
|
|
}
|
1061 |
|
|
|
1062 |
|
|
/* Print typedefs defined in this class. */
|
1063 |
|
|
|
1064 |
|
|
if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0)
|
1065 |
|
|
{
|
1066 |
|
|
if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
|
1067 |
|
|
fprintf_filtered (stream, "\n");
|
1068 |
|
|
|
1069 |
|
|
for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
|
1070 |
|
|
{
|
1071 |
|
|
struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
|
1072 |
|
|
|
1073 |
|
|
/* Dereference the typedef declaration itself. */
|
1074 |
|
|
gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
|
1075 |
|
|
target = TYPE_TARGET_TYPE (target);
|
1076 |
|
|
|
1077 |
|
|
print_spaces_filtered (level + 4, stream);
|
1078 |
|
|
fprintf_filtered (stream, "typedef ");
|
1079 |
|
|
c_print_type (target, TYPE_TYPEDEF_FIELD_NAME (type, i),
|
1080 |
|
|
stream, show - 1, level + 4);
|
1081 |
|
|
fprintf_filtered (stream, ";\n");
|
1082 |
|
|
}
|
1083 |
|
|
}
|
1084 |
|
|
|
1085 |
|
|
fprintfi_filtered (level, stream, "}");
|
1086 |
|
|
|
1087 |
|
|
if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
|
1088 |
|
|
fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
|
1089 |
|
|
TYPE_LOCALTYPE_FILE (type),
|
1090 |
|
|
TYPE_LOCALTYPE_LINE (type));
|
1091 |
|
|
}
|
1092 |
|
|
break;
|
1093 |
|
|
|
1094 |
|
|
case TYPE_CODE_ENUM:
|
1095 |
|
|
c_type_print_modifier (type, stream, 0, 1);
|
1096 |
|
|
fprintf_filtered (stream, "enum ");
|
1097 |
|
|
/* Print the tag name if it exists.
|
1098 |
|
|
The aCC compiler emits a spurious
|
1099 |
|
|
"{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
|
1100 |
|
|
tag for unnamed struct/union/enum's, which we don't
|
1101 |
|
|
want to print. */
|
1102 |
|
|
if (TYPE_TAG_NAME (type) != NULL
|
1103 |
|
|
&& strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
|
1104 |
|
|
{
|
1105 |
|
|
fputs_filtered (TYPE_TAG_NAME (type), stream);
|
1106 |
|
|
if (show > 0)
|
1107 |
|
|
fputs_filtered (" ", stream);
|
1108 |
|
|
}
|
1109 |
|
|
|
1110 |
|
|
wrap_here (" ");
|
1111 |
|
|
if (show < 0)
|
1112 |
|
|
{
|
1113 |
|
|
/* If we just printed a tag name, no need to print anything else. */
|
1114 |
|
|
if (TYPE_TAG_NAME (type) == NULL)
|
1115 |
|
|
fprintf_filtered (stream, "{...}");
|
1116 |
|
|
}
|
1117 |
|
|
else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
|
1118 |
|
|
{
|
1119 |
|
|
fprintf_filtered (stream, "{");
|
1120 |
|
|
len = TYPE_NFIELDS (type);
|
1121 |
|
|
lastval = 0;
|
1122 |
|
|
for (i = 0; i < len; i++)
|
1123 |
|
|
{
|
1124 |
|
|
QUIT;
|
1125 |
|
|
if (i)
|
1126 |
|
|
fprintf_filtered (stream, ", ");
|
1127 |
|
|
wrap_here (" ");
|
1128 |
|
|
fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
|
1129 |
|
|
if (lastval != TYPE_FIELD_BITPOS (type, i))
|
1130 |
|
|
{
|
1131 |
|
|
fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
|
1132 |
|
|
lastval = TYPE_FIELD_BITPOS (type, i);
|
1133 |
|
|
}
|
1134 |
|
|
lastval++;
|
1135 |
|
|
}
|
1136 |
|
|
fprintf_filtered (stream, "}");
|
1137 |
|
|
}
|
1138 |
|
|
break;
|
1139 |
|
|
|
1140 |
|
|
case TYPE_CODE_VOID:
|
1141 |
|
|
fprintf_filtered (stream, "void");
|
1142 |
|
|
break;
|
1143 |
|
|
|
1144 |
|
|
case TYPE_CODE_UNDEF:
|
1145 |
|
|
fprintf_filtered (stream, _("struct <unknown>"));
|
1146 |
|
|
break;
|
1147 |
|
|
|
1148 |
|
|
case TYPE_CODE_ERROR:
|
1149 |
|
|
fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
|
1150 |
|
|
break;
|
1151 |
|
|
|
1152 |
|
|
case TYPE_CODE_RANGE:
|
1153 |
|
|
/* This should not occur */
|
1154 |
|
|
fprintf_filtered (stream, _("<range type>"));
|
1155 |
|
|
break;
|
1156 |
|
|
|
1157 |
|
|
case TYPE_CODE_NAMESPACE:
|
1158 |
|
|
fputs_filtered ("namespace ", stream);
|
1159 |
|
|
fputs_filtered (TYPE_TAG_NAME (type), stream);
|
1160 |
|
|
break;
|
1161 |
|
|
|
1162 |
|
|
default:
|
1163 |
|
|
/* Handle types not explicitly handled by the other cases,
|
1164 |
|
|
such as fundamental types. For these, just print whatever
|
1165 |
|
|
the type name is, as recorded in the type itself. If there
|
1166 |
|
|
is no type name, then complain. */
|
1167 |
|
|
if (TYPE_NAME (type) != NULL)
|
1168 |
|
|
{
|
1169 |
|
|
c_type_print_modifier (type, stream, 0, 1);
|
1170 |
|
|
fputs_filtered (TYPE_NAME (type), stream);
|
1171 |
|
|
}
|
1172 |
|
|
else
|
1173 |
|
|
{
|
1174 |
|
|
/* At least for dump_symtab, it is important that this not be
|
1175 |
|
|
an error (). */
|
1176 |
|
|
fprintf_filtered (stream, _("<invalid type code %d>"),
|
1177 |
|
|
TYPE_CODE (type));
|
1178 |
|
|
}
|
1179 |
|
|
break;
|
1180 |
|
|
}
|
1181 |
|
|
}
|