Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Support for printing Modula 2 values for GDB, the GNU debugger. |
a8d6eb4a | 2 | |
6aba47ca | 3 | Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998, 2000, 2005, 2006, |
7b6bb8da | 4 | 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. |
c906108c | 5 | |
c5aa993b | 6 | This file is part of GDB. |
c906108c | 7 | |
c5aa993b JM |
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 | |
a9762ec7 | 10 | the Free Software Foundation; either version 3 of the License, or |
c5aa993b | 11 | (at your option) any later version. |
c906108c | 12 | |
c5aa993b JM |
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. | |
c906108c | 17 | |
c5aa993b | 18 | You should have received a copy of the GNU General Public License |
a9762ec7 | 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c906108c SS |
20 | |
21 | #include "defs.h" | |
c906108c SS |
22 | #include "symtab.h" |
23 | #include "gdbtypes.h" | |
72019c9c GM |
24 | #include "expression.h" |
25 | #include "value.h" | |
26 | #include "valprint.h" | |
27 | #include "language.h" | |
28 | #include "typeprint.h" | |
a8d6eb4a | 29 | #include "c-lang.h" |
72019c9c GM |
30 | #include "m2-lang.h" |
31 | #include "target.h" | |
32 | ||
79a45b7d TT |
33 | static int print_unpacked_pointer (struct type *type, |
34 | CORE_ADDR address, CORE_ADDR addr, | |
35 | const struct value_print_options *options, | |
36 | struct ui_file *stream); | |
844781a1 GM |
37 | static void |
38 | m2_print_array_contents (struct type *type, const gdb_byte *valaddr, | |
39 | int embedded_offset, CORE_ADDR address, | |
79a45b7d | 40 | struct ui_file *stream, int recurse, |
0e03807e | 41 | const struct value *val, |
79a45b7d TT |
42 | const struct value_print_options *options, |
43 | int len); | |
72019c9c GM |
44 | |
45 | ||
46 | /* Print function pointer with inferior address ADDRESS onto stdio | |
47 | stream STREAM. */ | |
48 | ||
49 | static void | |
50810684 UW |
50 | print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address, |
51 | struct ui_file *stream, int addressprint) | |
72019c9c | 52 | { |
50810684 | 53 | CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address, |
72019c9c GM |
54 | ¤t_target); |
55 | ||
56 | /* If the function pointer is represented by a description, print the | |
57 | address of the description. */ | |
58 | if (addressprint && func_addr != address) | |
59 | { | |
60 | fputs_filtered ("@", stream); | |
5af949e3 | 61 | fputs_filtered (paddress (gdbarch, address), stream); |
72019c9c GM |
62 | fputs_filtered (": ", stream); |
63 | } | |
5af949e3 | 64 | print_address_demangle (gdbarch, func_addr, stream, demangle); |
72019c9c GM |
65 | } |
66 | ||
844781a1 GM |
67 | /* get_long_set_bounds - assigns the bounds of the long set to low and |
68 | high. */ | |
72019c9c GM |
69 | |
70 | int | |
71 | get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high) | |
72 | { | |
73 | int len, i; | |
74 | ||
75 | if (TYPE_CODE (type) == TYPE_CODE_STRUCT) | |
76 | { | |
77 | len = TYPE_NFIELDS (type); | |
78 | i = TYPE_N_BASECLASSES (type); | |
79 | if (len == 0) | |
80 | return 0; | |
81 | *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i))); | |
82 | *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, | |
83 | len-1))); | |
84 | return 1; | |
85 | } | |
86 | error (_("expecting long_set")); | |
87 | return 0; | |
88 | } | |
89 | ||
90 | static void | |
91 | m2_print_long_set (struct type *type, const gdb_byte *valaddr, | |
92 | int embedded_offset, CORE_ADDR address, | |
79a45b7d | 93 | struct ui_file *stream) |
72019c9c GM |
94 | { |
95 | int empty_set = 1; | |
96 | int element_seen = 0; | |
97 | LONGEST previous_low = 0; | |
98 | LONGEST previous_high= 0; | |
99 | LONGEST i, low_bound, high_bound; | |
100 | LONGEST field_low, field_high; | |
101 | struct type *range; | |
102 | int len, field; | |
103 | struct type *target; | |
104 | int bitval; | |
105 | ||
106 | CHECK_TYPEDEF (type); | |
107 | ||
108 | fprintf_filtered (stream, "{"); | |
109 | len = TYPE_NFIELDS (type); | |
110 | if (get_long_set_bounds (type, &low_bound, &high_bound)) | |
111 | { | |
112 | field = TYPE_N_BASECLASSES (type); | |
113 | range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field)); | |
114 | } | |
115 | else | |
116 | { | |
117 | fprintf_filtered (stream, " %s }", _("<unknown bounds of set>")); | |
118 | return; | |
119 | } | |
120 | ||
121 | target = TYPE_TARGET_TYPE (range); | |
72019c9c GM |
122 | |
123 | if (get_discrete_bounds (range, &field_low, &field_high) >= 0) | |
124 | { | |
125 | for (i = low_bound; i <= high_bound; i++) | |
126 | { | |
127 | bitval = value_bit_index (TYPE_FIELD_TYPE (type, field), | |
128 | (TYPE_FIELD_BITPOS (type, field) / 8) + | |
129 | valaddr + embedded_offset, i); | |
130 | if (bitval < 0) | |
131 | error (_("bit test is out of range")); | |
132 | else if (bitval > 0) | |
133 | { | |
134 | previous_high = i; | |
135 | if (! element_seen) | |
136 | { | |
137 | if (! empty_set) | |
138 | fprintf_filtered (stream, ", "); | |
139 | print_type_scalar (target, i, stream); | |
140 | empty_set = 0; | |
141 | element_seen = 1; | |
142 | previous_low = i; | |
143 | } | |
144 | } | |
145 | else | |
146 | { | |
147 | /* bit is not set */ | |
148 | if (element_seen) | |
149 | { | |
150 | if (previous_low+1 < previous_high) | |
151 | fprintf_filtered (stream, ".."); | |
152 | if (previous_low+1 < previous_high) | |
153 | print_type_scalar (target, previous_high, stream); | |
154 | element_seen = 0; | |
155 | } | |
156 | } | |
157 | if (i == field_high) | |
158 | { | |
159 | field++; | |
160 | if (field == len) | |
161 | break; | |
162 | range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field)); | |
163 | if (get_discrete_bounds (range, &field_low, &field_high) < 0) | |
164 | break; | |
165 | target = TYPE_TARGET_TYPE (range); | |
72019c9c GM |
166 | } |
167 | } | |
168 | if (element_seen) | |
169 | { | |
170 | if (previous_low+1 < previous_high) | |
171 | { | |
172 | fprintf_filtered (stream, ".."); | |
173 | print_type_scalar (target, previous_high, stream); | |
174 | } | |
175 | element_seen = 0; | |
176 | } | |
177 | fprintf_filtered (stream, "}"); | |
178 | } | |
179 | } | |
180 | ||
844781a1 GM |
181 | static void |
182 | m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr, | |
183 | int embedded_offset, CORE_ADDR address, | |
79a45b7d TT |
184 | struct ui_file *stream, int recurse, |
185 | const struct value_print_options *options) | |
844781a1 GM |
186 | { |
187 | struct type *content_type; | |
188 | CORE_ADDR addr; | |
189 | LONGEST len; | |
190 | struct value *val; | |
191 | ||
192 | CHECK_TYPEDEF (type); | |
193 | content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)); | |
194 | ||
195 | addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0), | |
196 | (TYPE_FIELD_BITPOS (type, 0) / 8) + | |
197 | valaddr + embedded_offset); | |
198 | ||
199 | val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)), | |
200 | addr); | |
201 | len = unpack_field_as_long (type, valaddr + embedded_offset, 1); | |
202 | ||
203 | fprintf_filtered (stream, "{"); | |
66d61a4c PA |
204 | m2_print_array_contents (value_type (val), |
205 | value_contents_for_printing (val), | |
844781a1 | 206 | value_embedded_offset (val), addr, stream, |
66d61a4c | 207 | recurse, val, options, len); |
844781a1 GM |
208 | fprintf_filtered (stream, ", HIGH = %d}", (int) len); |
209 | } | |
210 | ||
79a45b7d | 211 | static int |
72019c9c GM |
212 | print_unpacked_pointer (struct type *type, |
213 | CORE_ADDR address, CORE_ADDR addr, | |
79a45b7d TT |
214 | const struct value_print_options *options, |
215 | struct ui_file *stream) | |
72019c9c | 216 | { |
50810684 | 217 | struct gdbarch *gdbarch = get_type_arch (type); |
72019c9c GM |
218 | struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); |
219 | ||
220 | if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) | |
221 | { | |
222 | /* Try to print what function it points to. */ | |
50810684 UW |
223 | print_function_pointer_address (gdbarch, addr, stream, |
224 | options->addressprint); | |
72019c9c GM |
225 | /* Return value is irrelevant except for string pointers. */ |
226 | return 0; | |
227 | } | |
228 | ||
79a45b7d | 229 | if (options->addressprint && options->format != 's') |
5af949e3 | 230 | fputs_filtered (paddress (gdbarch, address), stream); |
72019c9c GM |
231 | |
232 | /* For a pointer to char or unsigned char, also print the string | |
233 | pointed to, unless pointer is null. */ | |
234 | ||
235 | if (TYPE_LENGTH (elttype) == 1 | |
236 | && TYPE_CODE (elttype) == TYPE_CODE_INT | |
79a45b7d | 237 | && (options->format == 0 || options->format == 's') |
72019c9c | 238 | && addr != 0) |
09ca9e2e | 239 | return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1, |
6c7a06a3 | 240 | stream, options); |
72019c9c GM |
241 | |
242 | return 0; | |
243 | } | |
244 | ||
245 | static void | |
844781a1 GM |
246 | print_variable_at_address (struct type *type, |
247 | const gdb_byte *valaddr, | |
79a45b7d TT |
248 | struct ui_file *stream, |
249 | int recurse, | |
250 | const struct value_print_options *options) | |
72019c9c | 251 | { |
5af949e3 | 252 | struct gdbarch *gdbarch = get_type_arch (type); |
72019c9c GM |
253 | CORE_ADDR addr = unpack_pointer (type, valaddr); |
254 | struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); | |
255 | ||
256 | fprintf_filtered (stream, "["); | |
5af949e3 | 257 | fputs_filtered (paddress (gdbarch, addr), stream); |
72019c9c GM |
258 | fprintf_filtered (stream, "] : "); |
259 | ||
260 | if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) | |
261 | { | |
262 | struct value *deref_val = | |
d8631d21 | 263 | value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr)); |
b8d56208 | 264 | |
79a45b7d | 265 | common_val_print (deref_val, stream, recurse, options, current_language); |
72019c9c GM |
266 | } |
267 | else | |
268 | fputs_filtered ("???", stream); | |
269 | } | |
270 | ||
844781a1 GM |
271 | |
272 | /* m2_print_array_contents - prints out the contents of an | |
273 | array up to a max_print values. | |
274 | It prints arrays of char as a string | |
275 | and all other data types as comma | |
276 | separated values. */ | |
277 | ||
278 | static void | |
279 | m2_print_array_contents (struct type *type, const gdb_byte *valaddr, | |
280 | int embedded_offset, CORE_ADDR address, | |
79a45b7d | 281 | struct ui_file *stream, int recurse, |
0e03807e | 282 | const struct value *val, |
79a45b7d TT |
283 | const struct value_print_options *options, |
284 | int len) | |
844781a1 GM |
285 | { |
286 | int eltlen; | |
287 | CHECK_TYPEDEF (type); | |
288 | ||
289 | if (TYPE_LENGTH (type) > 0) | |
290 | { | |
291 | eltlen = TYPE_LENGTH (type); | |
79a45b7d | 292 | if (options->prettyprint_arrays) |
844781a1 GM |
293 | print_spaces_filtered (2 + 2 * recurse, stream); |
294 | /* For an array of chars, print with string syntax. */ | |
295 | if (eltlen == 1 && | |
296 | ((TYPE_CODE (type) == TYPE_CODE_INT) | |
297 | || ((current_language->la_language == language_m2) | |
298 | && (TYPE_CODE (type) == TYPE_CODE_CHAR))) | |
79a45b7d | 299 | && (options->format == 0 || options->format == 's')) |
09ca9e2e | 300 | val_print_string (type, NULL, address, len+1, stream, options); |
844781a1 GM |
301 | else |
302 | { | |
303 | fprintf_filtered (stream, "{"); | |
490f124f | 304 | val_print_array_elements (type, valaddr, embedded_offset, |
0e03807e TT |
305 | address, stream, recurse, val, |
306 | options, 0); | |
844781a1 GM |
307 | fprintf_filtered (stream, "}"); |
308 | } | |
309 | } | |
310 | } | |
311 | ||
312 | ||
72019c9c GM |
313 | /* Print data of type TYPE located at VALADDR (within GDB), which came from |
314 | the inferior at address ADDRESS, onto stdio stream STREAM according to | |
79a45b7d | 315 | OPTIONS. The data at VALADDR is in target byte order. |
72019c9c GM |
316 | |
317 | If the data are a string pointer, returns the number of string characters | |
79a45b7d | 318 | printed. */ |
c906108c SS |
319 | |
320 | int | |
fc1a4b47 | 321 | m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, |
79a45b7d | 322 | CORE_ADDR address, struct ui_file *stream, int recurse, |
0e03807e | 323 | const struct value *original_value, |
79a45b7d | 324 | const struct value_print_options *options) |
c906108c | 325 | { |
5af949e3 | 326 | struct gdbarch *gdbarch = get_type_arch (type); |
025bb325 | 327 | unsigned int i = 0; /* Number of characters printed. */ |
72019c9c GM |
328 | unsigned len; |
329 | struct type *elttype; | |
330 | unsigned eltlen; | |
72019c9c GM |
331 | LONGEST val; |
332 | CORE_ADDR addr; | |
333 | ||
334 | CHECK_TYPEDEF (type); | |
335 | switch (TYPE_CODE (type)) | |
336 | { | |
337 | case TYPE_CODE_ARRAY: | |
338 | if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) | |
339 | { | |
340 | elttype = check_typedef (TYPE_TARGET_TYPE (type)); | |
341 | eltlen = TYPE_LENGTH (elttype); | |
342 | len = TYPE_LENGTH (type) / eltlen; | |
79a45b7d | 343 | if (options->prettyprint_arrays) |
72019c9c GM |
344 | print_spaces_filtered (2 + 2 * recurse, stream); |
345 | /* For an array of chars, print with string syntax. */ | |
346 | if (eltlen == 1 && | |
347 | ((TYPE_CODE (elttype) == TYPE_CODE_INT) | |
348 | || ((current_language->la_language == language_m2) | |
349 | && (TYPE_CODE (elttype) == TYPE_CODE_CHAR))) | |
79a45b7d | 350 | && (options->format == 0 || options->format == 's')) |
72019c9c GM |
351 | { |
352 | /* If requested, look for the first null char and only print | |
353 | elements up to it. */ | |
79a45b7d | 354 | if (options->stop_print_at_null) |
72019c9c GM |
355 | { |
356 | unsigned int temp_len; | |
357 | ||
025bb325 | 358 | /* Look for a NULL char. */ |
72019c9c GM |
359 | for (temp_len = 0; |
360 | (valaddr + embedded_offset)[temp_len] | |
79a45b7d | 361 | && temp_len < len && temp_len < options->print_max; |
72019c9c GM |
362 | temp_len++); |
363 | len = temp_len; | |
364 | } | |
365 | ||
6c7a06a3 | 366 | LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type), |
be759fcf PM |
367 | valaddr + embedded_offset, len, NULL, |
368 | 0, options); | |
72019c9c GM |
369 | i = len; |
370 | } | |
371 | else | |
372 | { | |
373 | fprintf_filtered (stream, "{"); | |
490f124f | 374 | val_print_array_elements (type, valaddr, embedded_offset, |
025bb325 MS |
375 | address, stream, |
376 | recurse, original_value, | |
0e03807e | 377 | options, 0); |
72019c9c GM |
378 | fprintf_filtered (stream, "}"); |
379 | } | |
380 | break; | |
381 | } | |
382 | /* Array of unspecified length: treat like pointer to first elt. */ | |
79a45b7d | 383 | print_unpacked_pointer (type, address, address, options, stream); |
72019c9c GM |
384 | break; |
385 | ||
386 | case TYPE_CODE_PTR: | |
387 | if (TYPE_CONST (type)) | |
388 | print_variable_at_address (type, valaddr + embedded_offset, | |
79a45b7d TT |
389 | stream, recurse, options); |
390 | else if (options->format && options->format != 's') | |
391 | print_scalar_formatted (valaddr + embedded_offset, type, | |
392 | options, 0, stream); | |
72019c9c GM |
393 | else |
394 | { | |
395 | addr = unpack_pointer (type, valaddr + embedded_offset); | |
79a45b7d | 396 | print_unpacked_pointer (type, addr, address, options, stream); |
72019c9c GM |
397 | } |
398 | break; | |
399 | ||
72019c9c GM |
400 | case TYPE_CODE_REF: |
401 | elttype = check_typedef (TYPE_TARGET_TYPE (type)); | |
79a45b7d | 402 | if (options->addressprint) |
72019c9c GM |
403 | { |
404 | CORE_ADDR addr | |
405 | = extract_typed_address (valaddr + embedded_offset, type); | |
b8d56208 | 406 | |
72019c9c | 407 | fprintf_filtered (stream, "@"); |
5af949e3 | 408 | fputs_filtered (paddress (gdbarch, addr), stream); |
79a45b7d | 409 | if (options->deref_ref) |
72019c9c GM |
410 | fputs_filtered (": ", stream); |
411 | } | |
412 | /* De-reference the reference. */ | |
79a45b7d | 413 | if (options->deref_ref) |
72019c9c GM |
414 | { |
415 | if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) | |
416 | { | |
417 | struct value *deref_val = | |
418 | value_at | |
419 | (TYPE_TARGET_TYPE (type), | |
d8631d21 | 420 | unpack_pointer (type, valaddr + embedded_offset)); |
b8d56208 | 421 | |
79a45b7d TT |
422 | common_val_print (deref_val, stream, recurse, options, |
423 | current_language); | |
72019c9c GM |
424 | } |
425 | else | |
426 | fputs_filtered ("???", stream); | |
427 | } | |
428 | break; | |
429 | ||
430 | case TYPE_CODE_UNION: | |
79a45b7d | 431 | if (recurse && !options->unionprint) |
72019c9c GM |
432 | { |
433 | fprintf_filtered (stream, "{...}"); | |
434 | break; | |
435 | } | |
436 | /* Fall through. */ | |
437 | case TYPE_CODE_STRUCT: | |
438 | if (m2_is_long_set (type)) | |
439 | m2_print_long_set (type, valaddr, embedded_offset, address, | |
79a45b7d | 440 | stream); |
844781a1 GM |
441 | else if (m2_is_unbounded_array (type)) |
442 | m2_print_unbounded_array (type, valaddr, embedded_offset, | |
79a45b7d | 443 | address, stream, recurse, options); |
72019c9c GM |
444 | else |
445 | cp_print_value_fields (type, type, valaddr, embedded_offset, | |
0e03807e TT |
446 | address, stream, recurse, original_value, |
447 | options, NULL, 0); | |
72019c9c GM |
448 | break; |
449 | ||
450 | case TYPE_CODE_ENUM: | |
79a45b7d | 451 | if (options->format) |
72019c9c GM |
452 | { |
453 | print_scalar_formatted (valaddr + embedded_offset, type, | |
79a45b7d | 454 | options, 0, stream); |
72019c9c GM |
455 | break; |
456 | } | |
457 | len = TYPE_NFIELDS (type); | |
458 | val = unpack_long (type, valaddr + embedded_offset); | |
459 | for (i = 0; i < len; i++) | |
460 | { | |
461 | QUIT; | |
462 | if (val == TYPE_FIELD_BITPOS (type, i)) | |
463 | { | |
464 | break; | |
465 | } | |
466 | } | |
467 | if (i < len) | |
468 | { | |
469 | fputs_filtered (TYPE_FIELD_NAME (type, i), stream); | |
470 | } | |
471 | else | |
472 | { | |
473 | print_longest (stream, 'd', 0, val); | |
474 | } | |
475 | break; | |
476 | ||
477 | case TYPE_CODE_FUNC: | |
79a45b7d | 478 | if (options->format) |
72019c9c GM |
479 | { |
480 | print_scalar_formatted (valaddr + embedded_offset, type, | |
79a45b7d | 481 | options, 0, stream); |
72019c9c GM |
482 | break; |
483 | } | |
484 | /* FIXME, we should consider, at least for ANSI C language, eliminating | |
485 | the distinction made between FUNCs and POINTERs to FUNCs. */ | |
486 | fprintf_filtered (stream, "{"); | |
487 | type_print (type, "", stream, -1); | |
488 | fprintf_filtered (stream, "} "); | |
489 | /* Try to print what function it points to, and its address. */ | |
5af949e3 | 490 | print_address_demangle (gdbarch, address, stream, demangle); |
72019c9c GM |
491 | break; |
492 | ||
493 | case TYPE_CODE_BOOL: | |
79a45b7d TT |
494 | if (options->format || options->output_format) |
495 | { | |
496 | struct value_print_options opts = *options; | |
b8d56208 | 497 | |
79a45b7d TT |
498 | opts.format = (options->format ? options->format |
499 | : options->output_format); | |
500 | print_scalar_formatted (valaddr + embedded_offset, type, | |
501 | &opts, 0, stream); | |
502 | } | |
72019c9c GM |
503 | else |
504 | { | |
505 | val = unpack_long (type, valaddr + embedded_offset); | |
506 | if (val == 0) | |
507 | fputs_filtered ("FALSE", stream); | |
508 | else if (val == 1) | |
509 | fputs_filtered ("TRUE", stream); | |
510 | else | |
511 | fprintf_filtered (stream, "%ld)", (long int) val); | |
512 | } | |
513 | break; | |
514 | ||
515 | case TYPE_CODE_RANGE: | |
516 | if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type))) | |
517 | { | |
518 | m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset, | |
0e03807e | 519 | address, stream, recurse, original_value, options); |
72019c9c GM |
520 | break; |
521 | } | |
522 | /* FIXME: create_range_type does not set the unsigned bit in a | |
523 | range type (I think it probably should copy it from the target | |
524 | type), so we won't print values which are too large to | |
525 | fit in a signed integer correctly. */ | |
526 | /* FIXME: Doesn't handle ranges of enums correctly. (Can't just | |
527 | print with the target type, though, because the size of our type | |
528 | and the target type might differ). */ | |
529 | /* FALLTHROUGH */ | |
530 | ||
531 | case TYPE_CODE_INT: | |
79a45b7d TT |
532 | if (options->format || options->output_format) |
533 | { | |
534 | struct value_print_options opts = *options; | |
b8d56208 | 535 | |
79a45b7d TT |
536 | opts.format = (options->format ? options->format |
537 | : options->output_format); | |
538 | print_scalar_formatted (valaddr + embedded_offset, type, | |
539 | &opts, 0, stream); | |
540 | } | |
72019c9c GM |
541 | else |
542 | val_print_type_code_int (type, valaddr + embedded_offset, stream); | |
543 | break; | |
544 | ||
545 | case TYPE_CODE_CHAR: | |
79a45b7d TT |
546 | if (options->format || options->output_format) |
547 | { | |
548 | struct value_print_options opts = *options; | |
b8d56208 | 549 | |
79a45b7d TT |
550 | opts.format = (options->format ? options->format |
551 | : options->output_format); | |
552 | print_scalar_formatted (valaddr + embedded_offset, type, | |
553 | &opts, 0, stream); | |
554 | } | |
72019c9c GM |
555 | else |
556 | { | |
557 | val = unpack_long (type, valaddr + embedded_offset); | |
558 | if (TYPE_UNSIGNED (type)) | |
559 | fprintf_filtered (stream, "%u", (unsigned int) val); | |
560 | else | |
561 | fprintf_filtered (stream, "%d", (int) val); | |
562 | fputs_filtered (" ", stream); | |
6c7a06a3 | 563 | LA_PRINT_CHAR ((unsigned char) val, type, stream); |
72019c9c GM |
564 | } |
565 | break; | |
566 | ||
567 | case TYPE_CODE_FLT: | |
79a45b7d | 568 | if (options->format) |
72019c9c | 569 | print_scalar_formatted (valaddr + embedded_offset, type, |
79a45b7d | 570 | options, 0, stream); |
72019c9c GM |
571 | else |
572 | print_floating (valaddr + embedded_offset, type, stream); | |
573 | break; | |
574 | ||
575 | case TYPE_CODE_METHOD: | |
576 | break; | |
577 | ||
578 | case TYPE_CODE_BITSTRING: | |
579 | case TYPE_CODE_SET: | |
580 | elttype = TYPE_INDEX_TYPE (type); | |
581 | CHECK_TYPEDEF (elttype); | |
582 | if (TYPE_STUB (elttype)) | |
583 | { | |
584 | fprintf_filtered (stream, _("<incomplete type>")); | |
585 | gdb_flush (stream); | |
586 | break; | |
587 | } | |
588 | else | |
589 | { | |
590 | struct type *range = elttype; | |
591 | LONGEST low_bound, high_bound; | |
592 | int i; | |
593 | int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING; | |
594 | int need_comma = 0; | |
595 | ||
596 | if (is_bitstring) | |
597 | fputs_filtered ("B'", stream); | |
598 | else | |
599 | fputs_filtered ("{", stream); | |
600 | ||
601 | i = get_discrete_bounds (range, &low_bound, &high_bound); | |
602 | maybe_bad_bstring: | |
603 | if (i < 0) | |
604 | { | |
605 | fputs_filtered (_("<error value>"), stream); | |
606 | goto done; | |
607 | } | |
608 | ||
609 | for (i = low_bound; i <= high_bound; i++) | |
610 | { | |
611 | int element = value_bit_index (type, valaddr + embedded_offset, | |
612 | i); | |
b8d56208 | 613 | |
72019c9c GM |
614 | if (element < 0) |
615 | { | |
616 | i = element; | |
617 | goto maybe_bad_bstring; | |
618 | } | |
619 | if (is_bitstring) | |
620 | fprintf_filtered (stream, "%d", element); | |
621 | else if (element) | |
622 | { | |
623 | if (need_comma) | |
624 | fputs_filtered (", ", stream); | |
625 | print_type_scalar (range, i, stream); | |
626 | need_comma = 1; | |
627 | ||
628 | if (i + 1 <= high_bound | |
629 | && value_bit_index (type, valaddr + embedded_offset, | |
630 | ++i)) | |
631 | { | |
632 | int j = i; | |
b8d56208 | 633 | |
72019c9c GM |
634 | fputs_filtered ("..", stream); |
635 | while (i + 1 <= high_bound | |
636 | && value_bit_index (type, | |
637 | valaddr + embedded_offset, | |
638 | ++i)) | |
639 | j = i; | |
640 | print_type_scalar (range, j, stream); | |
641 | } | |
642 | } | |
643 | } | |
644 | done: | |
645 | if (is_bitstring) | |
646 | fputs_filtered ("'", stream); | |
647 | else | |
648 | fputs_filtered ("}", stream); | |
649 | } | |
650 | break; | |
651 | ||
652 | case TYPE_CODE_VOID: | |
653 | fprintf_filtered (stream, "void"); | |
654 | break; | |
655 | ||
656 | case TYPE_CODE_ERROR: | |
b00fdb78 | 657 | fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type)); |
72019c9c GM |
658 | break; |
659 | ||
660 | case TYPE_CODE_UNDEF: | |
661 | /* This happens (without TYPE_FLAG_STUB set) on systems which don't use | |
662 | dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar" | |
663 | and no complete type for struct foo in that file. */ | |
664 | fprintf_filtered (stream, _("<incomplete type>")); | |
665 | break; | |
666 | ||
667 | default: | |
668 | error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type)); | |
669 | } | |
670 | gdb_flush (stream); | |
671 | return (0); | |
c906108c | 672 | } |