[PATCH] Add micromips support to the MIPS simulator
[deliverable/binutils-gdb.git] / gdb / valprint.c
CommitLineData
c906108c 1/* Print values for GDB, the GNU debugger.
5c1c87f0 2
32d0add0 3 Copyright (C) 1986-2015 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#include "defs.h"
c906108c
SS
21#include "symtab.h"
22#include "gdbtypes.h"
23#include "value.h"
24#include "gdbcore.h"
25#include "gdbcmd.h"
26#include "target.h"
c906108c 27#include "language.h"
c906108c
SS
28#include "annotate.h"
29#include "valprint.h"
39424bef 30#include "floatformat.h"
d16aafd8 31#include "doublest.h"
7678ef8f 32#include "dfp.h"
6dddc817 33#include "extension.h"
0c3acc09 34#include "ada-lang.h"
3b2b8fea
TT
35#include "gdb_obstack.h"
36#include "charset.h"
37#include <ctype.h>
c906108c 38
0d63ecda
KS
39/* Maximum number of wchars returned from wchar_iterate. */
40#define MAX_WCHARS 4
41
42/* A convenience macro to compute the size of a wchar_t buffer containing X
43 characters. */
44#define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
45
46/* Character buffer size saved while iterating over wchars. */
47#define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
48
49/* A structure to encapsulate state information from iterated
50 character conversions. */
51struct converted_character
52{
53 /* The number of characters converted. */
54 int num_chars;
55
56 /* The result of the conversion. See charset.h for more. */
57 enum wchar_iterate_result result;
58
59 /* The (saved) converted character(s). */
60 gdb_wchar_t chars[WCHAR_BUFLEN_MAX];
61
62 /* The first converted target byte. */
63 const gdb_byte *buf;
64
65 /* The number of bytes converted. */
66 size_t buflen;
67
68 /* How many times this character(s) is repeated. */
69 int repeat_count;
70};
71
72typedef struct converted_character converted_character_d;
73DEF_VEC_O (converted_character_d);
74
e7045703
DE
75/* Command lists for set/show print raw. */
76struct cmd_list_element *setprintrawlist;
77struct cmd_list_element *showprintrawlist;
0d63ecda 78
c906108c
SS
79/* Prototypes for local functions */
80
777ea8f1 81static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
578d3588 82 int len, int *errptr);
917317f4 83
a14ed312 84static void show_print (char *, int);
c906108c 85
a14ed312 86static void set_print (char *, int);
c906108c 87
a14ed312 88static void set_radix (char *, int);
c906108c 89
a14ed312 90static void show_radix (char *, int);
c906108c 91
a14ed312 92static void set_input_radix (char *, int, struct cmd_list_element *);
c906108c 93
a14ed312 94static void set_input_radix_1 (int, unsigned);
c906108c 95
a14ed312 96static void set_output_radix (char *, int, struct cmd_list_element *);
c906108c 97
a14ed312 98static void set_output_radix_1 (int, unsigned);
c906108c 99
a14ed312 100void _initialize_valprint (void);
c906108c 101
581e13c1 102#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
79a45b7d
TT
103
104struct value_print_options user_print_options =
105{
2a998fc0
DE
106 Val_prettyformat_default, /* prettyformat */
107 0, /* prettyformat_arrays */
108 0, /* prettyformat_structs */
79a45b7d
TT
109 0, /* vtblprint */
110 1, /* unionprint */
111 1, /* addressprint */
112 0, /* objectprint */
113 PRINT_MAX_DEFAULT, /* print_max */
114 10, /* repeat_count_threshold */
115 0, /* output_format */
116 0, /* format */
117 0, /* stop_print_at_null */
79a45b7d
TT
118 0, /* print_array_indexes */
119 0, /* deref_ref */
120 1, /* static_field_print */
a6bac58e
TT
121 1, /* pascal_static_field_print */
122 0, /* raw */
9cb709b6
TT
123 0, /* summary */
124 1 /* symbol_print */
79a45b7d
TT
125};
126
127/* Initialize *OPTS to be a copy of the user print options. */
128void
129get_user_print_options (struct value_print_options *opts)
130{
131 *opts = user_print_options;
132}
133
134/* Initialize *OPTS to be a copy of the user print options, but with
2a998fc0 135 pretty-formatting disabled. */
79a45b7d 136void
2a998fc0 137get_no_prettyformat_print_options (struct value_print_options *opts)
79a45b7d
TT
138{
139 *opts = user_print_options;
2a998fc0 140 opts->prettyformat = Val_no_prettyformat;
79a45b7d
TT
141}
142
143/* Initialize *OPTS to be a copy of the user print options, but using
144 FORMAT as the formatting option. */
145void
146get_formatted_print_options (struct value_print_options *opts,
147 char format)
148{
149 *opts = user_print_options;
150 opts->format = format;
151}
152
920d2a44
AC
153static void
154show_print_max (struct ui_file *file, int from_tty,
155 struct cmd_list_element *c, const char *value)
156{
3e43a32a
MS
157 fprintf_filtered (file,
158 _("Limit on string chars or array "
159 "elements to print is %s.\n"),
920d2a44
AC
160 value);
161}
162
c906108c
SS
163
164/* Default input and output radixes, and output format letter. */
165
166unsigned input_radix = 10;
920d2a44
AC
167static void
168show_input_radix (struct ui_file *file, int from_tty,
169 struct cmd_list_element *c, const char *value)
170{
3e43a32a
MS
171 fprintf_filtered (file,
172 _("Default input radix for entering numbers is %s.\n"),
920d2a44
AC
173 value);
174}
175
c906108c 176unsigned output_radix = 10;
920d2a44
AC
177static void
178show_output_radix (struct ui_file *file, int from_tty,
179 struct cmd_list_element *c, const char *value)
180{
3e43a32a
MS
181 fprintf_filtered (file,
182 _("Default output radix for printing of values is %s.\n"),
920d2a44
AC
183 value);
184}
c906108c 185
e79af960
JB
186/* By default we print arrays without printing the index of each element in
187 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
188
e79af960
JB
189static void
190show_print_array_indexes (struct ui_file *file, int from_tty,
191 struct cmd_list_element *c, const char *value)
192{
193 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
194}
195
c906108c
SS
196/* Print repeat counts if there are more than this many repetitions of an
197 element in an array. Referenced by the low level language dependent
581e13c1 198 print routines. */
c906108c 199
920d2a44
AC
200static void
201show_repeat_count_threshold (struct ui_file *file, int from_tty,
202 struct cmd_list_element *c, const char *value)
203{
204 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
205 value);
206}
c906108c 207
581e13c1 208/* If nonzero, stops printing of char arrays at first null. */
c906108c 209
920d2a44
AC
210static void
211show_stop_print_at_null (struct ui_file *file, int from_tty,
212 struct cmd_list_element *c, const char *value)
213{
3e43a32a
MS
214 fprintf_filtered (file,
215 _("Printing of char arrays to stop "
216 "at first null char is %s.\n"),
920d2a44
AC
217 value);
218}
c906108c 219
581e13c1 220/* Controls pretty printing of structures. */
c906108c 221
920d2a44 222static void
2a998fc0 223show_prettyformat_structs (struct ui_file *file, int from_tty,
920d2a44
AC
224 struct cmd_list_element *c, const char *value)
225{
2a998fc0 226 fprintf_filtered (file, _("Pretty formatting of structures is %s.\n"), value);
920d2a44 227}
c906108c
SS
228
229/* Controls pretty printing of arrays. */
230
920d2a44 231static void
2a998fc0 232show_prettyformat_arrays (struct ui_file *file, int from_tty,
920d2a44
AC
233 struct cmd_list_element *c, const char *value)
234{
2a998fc0 235 fprintf_filtered (file, _("Pretty formatting of arrays is %s.\n"), value);
920d2a44 236}
c906108c
SS
237
238/* If nonzero, causes unions inside structures or other unions to be
581e13c1 239 printed. */
c906108c 240
920d2a44
AC
241static void
242show_unionprint (struct ui_file *file, int from_tty,
243 struct cmd_list_element *c, const char *value)
244{
3e43a32a
MS
245 fprintf_filtered (file,
246 _("Printing of unions interior to structures is %s.\n"),
920d2a44
AC
247 value);
248}
c906108c 249
581e13c1 250/* If nonzero, causes machine addresses to be printed in certain contexts. */
c906108c 251
920d2a44
AC
252static void
253show_addressprint (struct ui_file *file, int from_tty,
254 struct cmd_list_element *c, const char *value)
255{
256 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
257}
9cb709b6
TT
258
259static void
260show_symbol_print (struct ui_file *file, int from_tty,
261 struct cmd_list_element *c, const char *value)
262{
263 fprintf_filtered (file,
264 _("Printing of symbols when printing pointers is %s.\n"),
265 value);
266}
267
c906108c 268\f
c5aa993b 269
a6bac58e
TT
270/* A helper function for val_print. When printing in "summary" mode,
271 we want to print scalar arguments, but not aggregate arguments.
272 This function distinguishes between the two. */
273
6211c335
YQ
274int
275val_print_scalar_type_p (struct type *type)
a6bac58e 276{
f168693b 277 type = check_typedef (type);
a6bac58e
TT
278 while (TYPE_CODE (type) == TYPE_CODE_REF)
279 {
280 type = TYPE_TARGET_TYPE (type);
f168693b 281 type = check_typedef (type);
a6bac58e
TT
282 }
283 switch (TYPE_CODE (type))
284 {
285 case TYPE_CODE_ARRAY:
286 case TYPE_CODE_STRUCT:
287 case TYPE_CODE_UNION:
288 case TYPE_CODE_SET:
289 case TYPE_CODE_STRING:
a6bac58e
TT
290 return 0;
291 default:
292 return 1;
293 }
294}
295
a72c8f6a 296/* See its definition in value.h. */
0e03807e 297
a72c8f6a 298int
0e03807e
TT
299valprint_check_validity (struct ui_file *stream,
300 struct type *type,
4e07d55f 301 int embedded_offset,
0e03807e
TT
302 const struct value *val)
303{
f168693b 304 type = check_typedef (type);
0e03807e
TT
305
306 if (TYPE_CODE (type) != TYPE_CODE_UNION
307 && TYPE_CODE (type) != TYPE_CODE_STRUCT
308 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
309 {
9a0dc9e3
PA
310 if (value_bits_any_optimized_out (val,
311 TARGET_CHAR_BIT * embedded_offset,
312 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
0e03807e 313 {
901461f8 314 val_print_optimized_out (val, stream);
0e03807e
TT
315 return 0;
316 }
8cf6f0b1 317
4e07d55f 318 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
8cf6f0b1
TT
319 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
320 {
321 fputs_filtered (_("<synthetic pointer>"), stream);
322 return 0;
323 }
4e07d55f
PA
324
325 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
326 {
327 val_print_unavailable (stream);
328 return 0;
329 }
0e03807e
TT
330 }
331
332 return 1;
333}
334
585fdaa1 335void
901461f8 336val_print_optimized_out (const struct value *val, struct ui_file *stream)
585fdaa1 337{
901461f8 338 if (val != NULL && value_lval_const (val) == lval_register)
782d47df 339 val_print_not_saved (stream);
901461f8
PA
340 else
341 fprintf_filtered (stream, _("<optimized out>"));
585fdaa1
PA
342}
343
782d47df
PA
344void
345val_print_not_saved (struct ui_file *stream)
346{
347 fprintf_filtered (stream, _("<not saved>"));
348}
349
4e07d55f
PA
350void
351val_print_unavailable (struct ui_file *stream)
352{
353 fprintf_filtered (stream, _("<unavailable>"));
354}
355
8af8e3bc
PA
356void
357val_print_invalid_address (struct ui_file *stream)
358{
359 fprintf_filtered (stream, _("<invalid address>"));
360}
361
9f436164
SM
362/* Print a pointer based on the type of its target.
363
364 Arguments to this functions are roughly the same as those in
365 generic_val_print. A difference is that ADDRESS is the address to print,
366 with embedded_offset already added. ELTTYPE represents
367 the pointed type after check_typedef. */
368
369static void
370print_unpacked_pointer (struct type *type, struct type *elttype,
371 CORE_ADDR address, struct ui_file *stream,
372 const struct value_print_options *options)
373{
374 struct gdbarch *gdbarch = get_type_arch (type);
375
376 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
377 {
378 /* Try to print what function it points to. */
379 print_function_pointer_address (options, gdbarch, address, stream);
380 return;
381 }
382
383 if (options->symbol_print)
384 print_address_demangle (options, gdbarch, address, stream, demangle);
385 else if (options->addressprint)
386 fputs_filtered (paddress (gdbarch, address), stream);
387}
388
557dbe8a
SM
389/* generic_val_print helper for TYPE_CODE_ARRAY. */
390
391static void
392generic_val_print_array (struct type *type, const gdb_byte *valaddr,
393 int embedded_offset, CORE_ADDR address,
394 struct ui_file *stream, int recurse,
395 const struct value *original_value,
396 const struct value_print_options *options)
397{
398 struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
399 struct type *elttype = check_typedef (unresolved_elttype);
400
401 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
402 {
403 LONGEST low_bound, high_bound;
404
405 if (!get_array_bounds (type, &low_bound, &high_bound))
406 error (_("Could not determine the array high bound"));
407
408 if (options->prettyformat_arrays)
409 {
410 print_spaces_filtered (2 + 2 * recurse, stream);
411 }
412
413 fprintf_filtered (stream, "{");
414 val_print_array_elements (type, valaddr, embedded_offset,
415 address, stream,
416 recurse, original_value, options, 0);
417 fprintf_filtered (stream, "}");
418 }
419 else
420 {
421 /* Array of unspecified length: treat like pointer to first elt. */
422 print_unpacked_pointer (type, elttype, address + embedded_offset, stream,
423 options);
424 }
425
426}
427
81eb921a
SM
428/* generic_val_print helper for TYPE_CODE_PTR. */
429
430static void
431generic_val_print_ptr (struct type *type, const gdb_byte *valaddr,
432 int embedded_offset, struct ui_file *stream,
433 const struct value *original_value,
434 const struct value_print_options *options)
435{
3ae385af
SM
436 struct gdbarch *gdbarch = get_type_arch (type);
437 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
438
81eb921a
SM
439 if (options->format && options->format != 's')
440 {
441 val_print_scalar_formatted (type, valaddr, embedded_offset,
442 original_value, options, 0, stream);
443 }
444 else
445 {
446 struct type *unresolved_elttype = TYPE_TARGET_TYPE(type);
447 struct type *elttype = check_typedef (unresolved_elttype);
3ae385af
SM
448 CORE_ADDR addr = unpack_pointer (type,
449 valaddr + embedded_offset * unit_size);
81eb921a
SM
450
451 print_unpacked_pointer (type, elttype, addr, stream, options);
452 }
453}
454
45000ea2
SM
455
456/* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
457
458static void
459generic_val_print_memberptr (struct type *type, const gdb_byte *valaddr,
460 int embedded_offset, struct ui_file *stream,
461 const struct value *original_value,
462 const struct value_print_options *options)
463{
464 val_print_scalar_formatted (type, valaddr, embedded_offset,
465 original_value, options, 0, stream);
466}
467
fe43fede
SM
468/* generic_val_print helper for TYPE_CODE_REF. */
469
470static void
471generic_val_print_ref (struct type *type, const gdb_byte *valaddr,
472 int embedded_offset, struct ui_file *stream, int recurse,
473 const struct value *original_value,
474 const struct value_print_options *options)
475{
476 struct gdbarch *gdbarch = get_type_arch (type);
477 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
478
479 if (options->addressprint)
480 {
481 CORE_ADDR addr
482 = extract_typed_address (valaddr + embedded_offset, type);
483
484 fprintf_filtered (stream, "@");
485 fputs_filtered (paddress (gdbarch, addr), stream);
486 if (options->deref_ref)
487 fputs_filtered (": ", stream);
488 }
489 /* De-reference the reference. */
490 if (options->deref_ref)
491 {
492 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
493 {
494 struct value *deref_val;
495
496 deref_val = coerce_ref_if_computed (original_value);
497 if (deref_val != NULL)
498 {
499 /* More complicated computed references are not supported. */
500 gdb_assert (embedded_offset == 0);
501 }
502 else
503 deref_val = value_at (TYPE_TARGET_TYPE (type),
504 unpack_pointer (type,
505 (valaddr
506 + embedded_offset)));
507
508 common_val_print (deref_val, stream, recurse, options,
509 current_language);
510 }
511 else
512 fputs_filtered ("???", stream);
513 }
514}
515
ef0bc0dd
SM
516/* generic_val_print helper for TYPE_CODE_ENUM. */
517
518static void
519generic_val_print_enum (struct type *type, const gdb_byte *valaddr,
520 int embedded_offset, struct ui_file *stream,
521 const struct value *original_value,
522 const struct value_print_options *options)
523{
524 unsigned int i;
525 unsigned int len;
526 LONGEST val;
3ae385af
SM
527 struct gdbarch *gdbarch = get_type_arch (type);
528 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
ef0bc0dd
SM
529
530 if (options->format)
531 {
532 val_print_scalar_formatted (type, valaddr, embedded_offset,
533 original_value, options, 0, stream);
534 return;
535 }
536 len = TYPE_NFIELDS (type);
3ae385af 537 val = unpack_long (type, valaddr + embedded_offset * unit_size);
ef0bc0dd
SM
538 for (i = 0; i < len; i++)
539 {
540 QUIT;
541 if (val == TYPE_FIELD_ENUMVAL (type, i))
542 {
543 break;
544 }
545 }
546 if (i < len)
547 {
548 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
549 }
550 else if (TYPE_FLAG_ENUM (type))
551 {
552 int first = 1;
553
554 /* We have a "flag" enum, so we try to decompose it into
555 pieces as appropriate. A flag enum has disjoint
556 constants by definition. */
557 fputs_filtered ("(", stream);
558 for (i = 0; i < len; ++i)
559 {
560 QUIT;
561
562 if ((val & TYPE_FIELD_ENUMVAL (type, i)) != 0)
563 {
564 if (!first)
565 fputs_filtered (" | ", stream);
566 first = 0;
567
568 val &= ~TYPE_FIELD_ENUMVAL (type, i);
569 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
570 }
571 }
572
573 if (first || val != 0)
574 {
575 if (!first)
576 fputs_filtered (" | ", stream);
577 fputs_filtered ("unknown: ", stream);
578 print_longest (stream, 'd', 0, val);
579 }
580
581 fputs_filtered (")", stream);
582 }
583 else
584 print_longest (stream, 'd', 0, val);
585}
586
d93880bd
SM
587/* generic_val_print helper for TYPE_CODE_FLAGS. */
588
589static void
590generic_val_print_flags (struct type *type, const gdb_byte *valaddr,
591 int embedded_offset, struct ui_file *stream,
592 const struct value *original_value,
593 const struct value_print_options *options)
594
595{
596 if (options->format)
597 val_print_scalar_formatted (type, valaddr, embedded_offset, original_value,
598 options, 0, stream);
599 else
600 val_print_type_code_flags (type, valaddr + embedded_offset, stream);
601}
602
4a8c372f
SM
603/* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
604
605static void
606generic_val_print_func (struct type *type, const gdb_byte *valaddr,
607 int embedded_offset, CORE_ADDR address,
608 struct ui_file *stream,
609 const struct value *original_value,
610 const struct value_print_options *options)
611{
612 struct gdbarch *gdbarch = get_type_arch (type);
613
614 if (options->format)
615 {
616 val_print_scalar_formatted (type, valaddr, embedded_offset,
617 original_value, options, 0, stream);
618 }
619 else
620 {
621 /* FIXME, we should consider, at least for ANSI C language,
622 eliminating the distinction made between FUNCs and POINTERs
623 to FUNCs. */
624 fprintf_filtered (stream, "{");
625 type_print (type, "", stream, -1);
626 fprintf_filtered (stream, "} ");
627 /* Try to print what function it points to, and its address. */
628 print_address_demangle (options, gdbarch, address, stream, demangle);
629 }
630}
631
e5bead4b
SM
632/* generic_val_print helper for TYPE_CODE_BOOL. */
633
634static void
635generic_val_print_bool (struct type *type, const gdb_byte *valaddr,
636 int embedded_offset, struct ui_file *stream,
637 const struct value *original_value,
638 const struct value_print_options *options,
639 const struct generic_val_print_decorations *decorations)
640{
641 LONGEST val;
3ae385af
SM
642 struct gdbarch *gdbarch = get_type_arch (type);
643 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
e5bead4b
SM
644
645 if (options->format || options->output_format)
646 {
647 struct value_print_options opts = *options;
648 opts.format = (options->format ? options->format
649 : options->output_format);
650 val_print_scalar_formatted (type, valaddr, embedded_offset,
651 original_value, &opts, 0, stream);
652 }
653 else
654 {
3ae385af 655 val = unpack_long (type, valaddr + embedded_offset * unit_size);
e5bead4b
SM
656 if (val == 0)
657 fputs_filtered (decorations->false_name, stream);
658 else if (val == 1)
659 fputs_filtered (decorations->true_name, stream);
660 else
661 print_longest (stream, 'd', 0, val);
662 }
663}
664
b21b6342
SM
665/* generic_val_print helper for TYPE_CODE_INT. */
666
667static void
668generic_val_print_int (struct type *type, const gdb_byte *valaddr,
669 int embedded_offset, struct ui_file *stream,
670 const struct value *original_value,
671 const struct value_print_options *options)
672{
3ae385af
SM
673 struct gdbarch *gdbarch = get_type_arch (type);
674 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
675
b21b6342
SM
676 if (options->format || options->output_format)
677 {
678 struct value_print_options opts = *options;
679
680 opts.format = (options->format ? options->format
681 : options->output_format);
682 val_print_scalar_formatted (type, valaddr, embedded_offset,
683 original_value, &opts, 0, stream);
684 }
685 else
3ae385af
SM
686 val_print_type_code_int (type, valaddr + embedded_offset * unit_size,
687 stream);
b21b6342
SM
688}
689
385f5aff
SM
690/* generic_val_print helper for TYPE_CODE_CHAR. */
691
692static void
693generic_val_print_char (struct type *type, struct type *unresolved_type,
694 const gdb_byte *valaddr, int embedded_offset,
695 struct ui_file *stream,
696 const struct value *original_value,
697 const struct value_print_options *options)
698{
699 LONGEST val;
3ae385af
SM
700 struct gdbarch *gdbarch = get_type_arch (type);
701 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
385f5aff
SM
702
703 if (options->format || options->output_format)
704 {
705 struct value_print_options opts = *options;
706
707 opts.format = (options->format ? options->format
708 : options->output_format);
709 val_print_scalar_formatted (type, valaddr, embedded_offset,
710 original_value, &opts, 0, stream);
711 }
712 else
713 {
3ae385af 714 val = unpack_long (type, valaddr + embedded_offset * unit_size);
385f5aff
SM
715 if (TYPE_UNSIGNED (type))
716 fprintf_filtered (stream, "%u", (unsigned int) val);
717 else
718 fprintf_filtered (stream, "%d", (int) val);
719 fputs_filtered (" ", stream);
720 LA_PRINT_CHAR (val, unresolved_type, stream);
721 }
722}
723
7784724b
SM
724/* generic_val_print helper for TYPE_CODE_FLT. */
725
726static void
727generic_val_print_float (struct type *type, const gdb_byte *valaddr,
728 int embedded_offset, struct ui_file *stream,
729 const struct value *original_value,
730 const struct value_print_options *options)
731{
3ae385af
SM
732 struct gdbarch *gdbarch = get_type_arch (type);
733 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
734
7784724b
SM
735 if (options->format)
736 {
737 val_print_scalar_formatted (type, valaddr, embedded_offset,
738 original_value, options, 0, stream);
739 }
740 else
741 {
3ae385af 742 print_floating (valaddr + embedded_offset * unit_size, type, stream);
7784724b
SM
743 }
744}
745
9550ae5e
SM
746/* generic_val_print helper for TYPE_CODE_DECFLOAT. */
747
748static void
749generic_val_print_decfloat (struct type *type, const gdb_byte *valaddr,
750 int embedded_offset, struct ui_file *stream,
751 const struct value *original_value,
752 const struct value_print_options *options)
753{
3ae385af
SM
754 struct gdbarch *gdbarch = get_type_arch (type);
755 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
756
9550ae5e
SM
757 if (options->format)
758 val_print_scalar_formatted (type, valaddr, embedded_offset, original_value,
759 options, 0, stream);
760 else
3ae385af
SM
761 print_decimal_floating (valaddr + embedded_offset * unit_size, type,
762 stream);
9550ae5e
SM
763}
764
0c87c0bf
SM
765/* generic_val_print helper for TYPE_CODE_COMPLEX. */
766
767static void
768generic_val_print_complex (struct type *type, const gdb_byte *valaddr,
769 int embedded_offset, struct ui_file *stream,
770 const struct value *original_value,
771 const struct value_print_options *options,
772 const struct generic_val_print_decorations
773 *decorations)
774{
3ae385af
SM
775 struct gdbarch *gdbarch = get_type_arch (type);
776 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
777
0c87c0bf
SM
778 fprintf_filtered (stream, "%s", decorations->complex_prefix);
779 if (options->format)
780 val_print_scalar_formatted (TYPE_TARGET_TYPE (type), valaddr,
781 embedded_offset, original_value, options, 0,
782 stream);
783 else
3ae385af
SM
784 print_floating (valaddr + embedded_offset * unit_size,
785 TYPE_TARGET_TYPE (type), stream);
0c87c0bf
SM
786 fprintf_filtered (stream, "%s", decorations->complex_infix);
787 if (options->format)
788 val_print_scalar_formatted (TYPE_TARGET_TYPE (type), valaddr,
789 embedded_offset
3ae385af 790 + type_length_units (TYPE_TARGET_TYPE (type)),
0c87c0bf
SM
791 original_value, options, 0, stream);
792 else
3ae385af 793 print_floating (valaddr + embedded_offset * unit_size
0c87c0bf
SM
794 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
795 TYPE_TARGET_TYPE (type), stream);
796 fprintf_filtered (stream, "%s", decorations->complex_suffix);
797}
798
e88acd96
TT
799/* A generic val_print that is suitable for use by language
800 implementations of the la_val_print method. This function can
801 handle most type codes, though not all, notably exception
802 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
803 the caller.
804
805 Most arguments are as to val_print.
806
807 The additional DECORATIONS argument can be used to customize the
808 output in some small, language-specific ways. */
809
810void
811generic_val_print (struct type *type, const gdb_byte *valaddr,
812 int embedded_offset, CORE_ADDR address,
813 struct ui_file *stream, int recurse,
814 const struct value *original_value,
815 const struct value_print_options *options,
816 const struct generic_val_print_decorations *decorations)
817{
e88acd96 818 struct type *unresolved_type = type;
e88acd96 819
f168693b 820 type = check_typedef (type);
e88acd96
TT
821 switch (TYPE_CODE (type))
822 {
823 case TYPE_CODE_ARRAY:
557dbe8a
SM
824 generic_val_print_array (type, valaddr, embedded_offset, address, stream,
825 recurse, original_value, options);
9f436164 826 break;
e88acd96
TT
827
828 case TYPE_CODE_MEMBERPTR:
45000ea2
SM
829 generic_val_print_memberptr (type, valaddr, embedded_offset, stream,
830 original_value, options);
e88acd96
TT
831 break;
832
833 case TYPE_CODE_PTR:
81eb921a
SM
834 generic_val_print_ptr (type, valaddr, embedded_offset, stream,
835 original_value, options);
e88acd96
TT
836 break;
837
838 case TYPE_CODE_REF:
fe43fede
SM
839 generic_val_print_ref (type, valaddr, embedded_offset, stream, recurse,
840 original_value, options);
e88acd96
TT
841 break;
842
843 case TYPE_CODE_ENUM:
ef0bc0dd
SM
844 generic_val_print_enum (type, valaddr, embedded_offset, stream,
845 original_value, options);
e88acd96
TT
846 break;
847
848 case TYPE_CODE_FLAGS:
d93880bd
SM
849 generic_val_print_flags (type, valaddr, embedded_offset, stream,
850 original_value, options);
e88acd96
TT
851 break;
852
853 case TYPE_CODE_FUNC:
854 case TYPE_CODE_METHOD:
4a8c372f
SM
855 generic_val_print_func (type, valaddr, embedded_offset, address, stream,
856 original_value, options);
e88acd96
TT
857 break;
858
859 case TYPE_CODE_BOOL:
e5bead4b
SM
860 generic_val_print_bool (type, valaddr, embedded_offset, stream,
861 original_value, options, decorations);
e88acd96
TT
862 break;
863
864 case TYPE_CODE_RANGE:
0c9c3474 865 /* FIXME: create_static_range_type does not set the unsigned bit in a
e88acd96
TT
866 range type (I think it probably should copy it from the
867 target type), so we won't print values which are too large to
868 fit in a signed integer correctly. */
869 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
870 print with the target type, though, because the size of our
871 type and the target type might differ). */
872
873 /* FALLTHROUGH */
874
875 case TYPE_CODE_INT:
b21b6342
SM
876 generic_val_print_int (type, valaddr, embedded_offset, stream,
877 original_value, options);
e88acd96
TT
878 break;
879
880 case TYPE_CODE_CHAR:
385f5aff
SM
881 generic_val_print_char (type, unresolved_type, valaddr, embedded_offset,
882 stream, original_value, options);
e88acd96
TT
883 break;
884
885 case TYPE_CODE_FLT:
7784724b
SM
886 generic_val_print_float (type, valaddr, embedded_offset, stream,
887 original_value, options);
e88acd96
TT
888 break;
889
890 case TYPE_CODE_DECFLOAT:
9550ae5e
SM
891 generic_val_print_decfloat (type, valaddr, embedded_offset, stream,
892 original_value, options);
e88acd96
TT
893 break;
894
895 case TYPE_CODE_VOID:
896 fputs_filtered (decorations->void_name, stream);
897 break;
898
899 case TYPE_CODE_ERROR:
900 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
901 break;
902
903 case TYPE_CODE_UNDEF:
904 /* This happens (without TYPE_FLAG_STUB set) on systems which
905 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
906 "struct foo *bar" and no complete type for struct foo in that
907 file. */
908 fprintf_filtered (stream, _("<incomplete type>"));
909 break;
910
911 case TYPE_CODE_COMPLEX:
0c87c0bf
SM
912 generic_val_print_complex (type, valaddr, embedded_offset, stream,
913 original_value, options, decorations);
e88acd96
TT
914 break;
915
916 case TYPE_CODE_UNION:
917 case TYPE_CODE_STRUCT:
918 case TYPE_CODE_METHODPTR:
919 default:
920 error (_("Unhandled type code %d in symbol table."),
921 TYPE_CODE (type));
922 }
923 gdb_flush (stream);
924}
925
32b72a42
PA
926/* Print using the given LANGUAGE the data of type TYPE located at
927 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
928 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
929 STREAM according to OPTIONS. VAL is the whole object that came
930 from ADDRESS. VALADDR must point to the head of VAL's contents
931 buffer.
932
933 The language printers will pass down an adjusted EMBEDDED_OFFSET to
934 further helper subroutines as subfields of TYPE are printed. In
935 such cases, VALADDR is passed down unadjusted, as well as VAL, so
936 that VAL can be queried for metadata about the contents data being
937 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
938 buffer. For example: "has this field been optimized out", or "I'm
939 printing an object while inspecting a traceframe; has this
940 particular piece of data been collected?".
941
942 RECURSE indicates the amount of indentation to supply before
943 continuation lines; this amount is roughly twice the value of
35c0084b 944 RECURSE. */
32b72a42 945
35c0084b 946void
fc1a4b47 947val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
79a45b7d 948 CORE_ADDR address, struct ui_file *stream, int recurse,
0e03807e 949 const struct value *val,
79a45b7d 950 const struct value_print_options *options,
d8ca156b 951 const struct language_defn *language)
c906108c 952{
19ca80ba 953 int ret = 0;
79a45b7d 954 struct value_print_options local_opts = *options;
c906108c 955 struct type *real_type = check_typedef (type);
79a45b7d 956
2a998fc0
DE
957 if (local_opts.prettyformat == Val_prettyformat_default)
958 local_opts.prettyformat = (local_opts.prettyformat_structs
959 ? Val_prettyformat : Val_no_prettyformat);
c5aa993b 960
c906108c
SS
961 QUIT;
962
963 /* Ensure that the type is complete and not just a stub. If the type is
964 only a stub and we can't find and substitute its complete type, then
965 print appropriate string and return. */
966
74a9bb82 967 if (TYPE_STUB (real_type))
c906108c 968 {
0e03807e 969 fprintf_filtered (stream, _("<incomplete type>"));
c906108c 970 gdb_flush (stream);
35c0084b 971 return;
c906108c 972 }
c5aa993b 973
0e03807e 974 if (!valprint_check_validity (stream, real_type, embedded_offset, val))
35c0084b 975 return;
0e03807e 976
a6bac58e
TT
977 if (!options->raw)
978 {
6dddc817
DE
979 ret = apply_ext_lang_val_pretty_printer (type, valaddr, embedded_offset,
980 address, stream, recurse,
981 val, options, language);
a6bac58e 982 if (ret)
35c0084b 983 return;
a6bac58e
TT
984 }
985
986 /* Handle summary mode. If the value is a scalar, print it;
987 otherwise, print an ellipsis. */
6211c335 988 if (options->summary && !val_print_scalar_type_p (type))
a6bac58e
TT
989 {
990 fprintf_filtered (stream, "...");
35c0084b 991 return;
a6bac58e
TT
992 }
993
492d29ea 994 TRY
19ca80ba 995 {
d3eab38a
TT
996 language->la_val_print (type, valaddr, embedded_offset, address,
997 stream, recurse, val,
998 &local_opts);
19ca80ba 999 }
492d29ea
PA
1000 CATCH (except, RETURN_MASK_ERROR)
1001 {
1002 fprintf_filtered (stream, _("<error reading variable>"));
1003 }
1004 END_CATCH
c906108c
SS
1005}
1006
806048c6 1007/* Check whether the value VAL is printable. Return 1 if it is;
6501578c
YQ
1008 return 0 and print an appropriate error message to STREAM according to
1009 OPTIONS if it is not. */
c906108c 1010
806048c6 1011static int
6501578c
YQ
1012value_check_printable (struct value *val, struct ui_file *stream,
1013 const struct value_print_options *options)
c906108c
SS
1014{
1015 if (val == 0)
1016 {
806048c6 1017 fprintf_filtered (stream, _("<address of value unknown>"));
c906108c
SS
1018 return 0;
1019 }
806048c6 1020
0e03807e 1021 if (value_entirely_optimized_out (val))
c906108c 1022 {
6211c335 1023 if (options->summary && !val_print_scalar_type_p (value_type (val)))
6501578c
YQ
1024 fprintf_filtered (stream, "...");
1025 else
901461f8 1026 val_print_optimized_out (val, stream);
c906108c
SS
1027 return 0;
1028 }
806048c6 1029
eebc056c
AB
1030 if (value_entirely_unavailable (val))
1031 {
1032 if (options->summary && !val_print_scalar_type_p (value_type (val)))
1033 fprintf_filtered (stream, "...");
1034 else
1035 val_print_unavailable (stream);
1036 return 0;
1037 }
1038
bc3b79fd
TJB
1039 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
1040 {
1041 fprintf_filtered (stream, _("<internal function %s>"),
1042 value_internal_function_name (val));
1043 return 0;
1044 }
1045
806048c6
DJ
1046 return 1;
1047}
1048
d8ca156b 1049/* Print using the given LANGUAGE the value VAL onto stream STREAM according
79a45b7d 1050 to OPTIONS.
806048c6 1051
806048c6
DJ
1052 This is a preferable interface to val_print, above, because it uses
1053 GDB's value mechanism. */
1054
a1f5dd1b 1055void
79a45b7d
TT
1056common_val_print (struct value *val, struct ui_file *stream, int recurse,
1057 const struct value_print_options *options,
d8ca156b 1058 const struct language_defn *language)
806048c6 1059{
6501578c 1060 if (!value_check_printable (val, stream, options))
a1f5dd1b 1061 return;
806048c6 1062
0c3acc09
JB
1063 if (language->la_language == language_ada)
1064 /* The value might have a dynamic type, which would cause trouble
1065 below when trying to extract the value contents (since the value
1066 size is determined from the type size which is unknown). So
1067 get a fixed representation of our value. */
1068 val = ada_to_fixed_value (val);
1069
a1f5dd1b
TT
1070 val_print (value_type (val), value_contents_for_printing (val),
1071 value_embedded_offset (val), value_address (val),
1072 stream, recurse,
1073 val, options, language);
806048c6
DJ
1074}
1075
7348c5e1 1076/* Print on stream STREAM the value VAL according to OPTIONS. The value
8e069a98 1077 is printed using the current_language syntax. */
7348c5e1 1078
8e069a98 1079void
79a45b7d
TT
1080value_print (struct value *val, struct ui_file *stream,
1081 const struct value_print_options *options)
806048c6 1082{
6501578c 1083 if (!value_check_printable (val, stream, options))
8e069a98 1084 return;
806048c6 1085
a6bac58e
TT
1086 if (!options->raw)
1087 {
6dddc817
DE
1088 int r
1089 = apply_ext_lang_val_pretty_printer (value_type (val),
1090 value_contents_for_printing (val),
1091 value_embedded_offset (val),
1092 value_address (val),
1093 stream, 0,
1094 val, options, current_language);
a109c7c1 1095
a6bac58e 1096 if (r)
8e069a98 1097 return;
a6bac58e
TT
1098 }
1099
8e069a98 1100 LA_VALUE_PRINT (val, stream, options);
c906108c
SS
1101}
1102
1103/* Called by various <lang>_val_print routines to print
1104 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
1105 value. STREAM is where to print the value. */
1106
1107void
fc1a4b47 1108val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
fba45db2 1109 struct ui_file *stream)
c906108c 1110{
50810684 1111 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
d44e8473 1112
c906108c
SS
1113 if (TYPE_LENGTH (type) > sizeof (LONGEST))
1114 {
1115 LONGEST val;
1116
1117 if (TYPE_UNSIGNED (type)
1118 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
e17a4113 1119 byte_order, &val))
c906108c
SS
1120 {
1121 print_longest (stream, 'u', 0, val);
1122 }
1123 else
1124 {
1125 /* Signed, or we couldn't turn an unsigned value into a
1126 LONGEST. For signed values, one could assume two's
1127 complement (a reasonable assumption, I think) and do
1128 better than this. */
1129 print_hex_chars (stream, (unsigned char *) valaddr,
d44e8473 1130 TYPE_LENGTH (type), byte_order);
c906108c
SS
1131 }
1132 }
1133 else
1134 {
c906108c
SS
1135 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
1136 unpack_long (type, valaddr));
c906108c
SS
1137 }
1138}
1139
4f2aea11
MK
1140void
1141val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
1142 struct ui_file *stream)
1143{
befae759 1144 ULONGEST val = unpack_long (type, valaddr);
4f2aea11
MK
1145 int bitpos, nfields = TYPE_NFIELDS (type);
1146
1147 fputs_filtered ("[ ", stream);
1148 for (bitpos = 0; bitpos < nfields; bitpos++)
1149 {
316703b9
MK
1150 if (TYPE_FIELD_BITPOS (type, bitpos) != -1
1151 && (val & ((ULONGEST)1 << bitpos)))
4f2aea11
MK
1152 {
1153 if (TYPE_FIELD_NAME (type, bitpos))
1154 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
1155 else
1156 fprintf_filtered (stream, "#%d ", bitpos);
1157 }
1158 }
1159 fputs_filtered ("]", stream);
19c37f24 1160}
ab2188aa
PA
1161
1162/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
1163 according to OPTIONS and SIZE on STREAM. Format i is not supported
1164 at this level.
1165
1166 This is how the elements of an array or structure are printed
1167 with a format. */
ab2188aa
PA
1168
1169void
1170val_print_scalar_formatted (struct type *type,
1171 const gdb_byte *valaddr, int embedded_offset,
1172 const struct value *val,
1173 const struct value_print_options *options,
1174 int size,
1175 struct ui_file *stream)
1176{
3ae385af
SM
1177 struct gdbarch *arch = get_type_arch (type);
1178 int unit_size = gdbarch_addressable_memory_unit_size (arch);
1179
ab2188aa
PA
1180 gdb_assert (val != NULL);
1181 gdb_assert (valaddr == value_contents_for_printing_const (val));
1182
1183 /* If we get here with a string format, try again without it. Go
1184 all the way back to the language printers, which may call us
1185 again. */
1186 if (options->format == 's')
1187 {
1188 struct value_print_options opts = *options;
1189 opts.format = 0;
1190 opts.deref_ref = 0;
1191 val_print (type, valaddr, embedded_offset, 0, stream, 0, val, &opts,
1192 current_language);
1193 return;
1194 }
1195
1196 /* A scalar object that does not have all bits available can't be
1197 printed, because all bits contribute to its representation. */
9a0dc9e3
PA
1198 if (value_bits_any_optimized_out (val,
1199 TARGET_CHAR_BIT * embedded_offset,
1200 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
901461f8 1201 val_print_optimized_out (val, stream);
4e07d55f
PA
1202 else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
1203 val_print_unavailable (stream);
ab2188aa 1204 else
3ae385af 1205 print_scalar_formatted (valaddr + embedded_offset * unit_size, type,
ab2188aa 1206 options, size, stream);
4f2aea11
MK
1207}
1208
c906108c
SS
1209/* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1210 The raison d'etre of this function is to consolidate printing of
581e13c1 1211 LONG_LONG's into this one function. The format chars b,h,w,g are
bb599908 1212 from print_scalar_formatted(). Numbers are printed using C
581e13c1 1213 format.
bb599908
PH
1214
1215 USE_C_FORMAT means to use C format in all cases. Without it,
1216 'o' and 'x' format do not include the standard C radix prefix
1217 (leading 0 or 0x).
1218
1219 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1220 and was intended to request formating according to the current
1221 language and would be used for most integers that GDB prints. The
1222 exceptional cases were things like protocols where the format of
1223 the integer is a protocol thing, not a user-visible thing). The
1224 parameter remains to preserve the information of what things might
1225 be printed with language-specific format, should we ever resurrect
581e13c1 1226 that capability. */
c906108c
SS
1227
1228void
bb599908 1229print_longest (struct ui_file *stream, int format, int use_c_format,
fba45db2 1230 LONGEST val_long)
c906108c 1231{
2bfb72ee
AC
1232 const char *val;
1233
c906108c
SS
1234 switch (format)
1235 {
1236 case 'd':
bb599908 1237 val = int_string (val_long, 10, 1, 0, 1); break;
c906108c 1238 case 'u':
bb599908 1239 val = int_string (val_long, 10, 0, 0, 1); break;
c906108c 1240 case 'x':
bb599908 1241 val = int_string (val_long, 16, 0, 0, use_c_format); break;
c906108c 1242 case 'b':
bb599908 1243 val = int_string (val_long, 16, 0, 2, 1); break;
c906108c 1244 case 'h':
bb599908 1245 val = int_string (val_long, 16, 0, 4, 1); break;
c906108c 1246 case 'w':
bb599908 1247 val = int_string (val_long, 16, 0, 8, 1); break;
c906108c 1248 case 'g':
bb599908 1249 val = int_string (val_long, 16, 0, 16, 1); break;
c906108c
SS
1250 break;
1251 case 'o':
bb599908 1252 val = int_string (val_long, 8, 0, 0, use_c_format); break;
c906108c 1253 default:
3e43a32a
MS
1254 internal_error (__FILE__, __LINE__,
1255 _("failed internal consistency check"));
bb599908 1256 }
2bfb72ee 1257 fputs_filtered (val, stream);
c906108c
SS
1258}
1259
c906108c
SS
1260/* This used to be a macro, but I don't think it is called often enough
1261 to merit such treatment. */
1262/* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1263 arguments to a function, number in a value history, register number, etc.)
1264 where the value must not be larger than can fit in an int. */
1265
1266int
fba45db2 1267longest_to_int (LONGEST arg)
c906108c 1268{
581e13c1 1269 /* Let the compiler do the work. */
c906108c
SS
1270 int rtnval = (int) arg;
1271
581e13c1 1272 /* Check for overflows or underflows. */
c906108c
SS
1273 if (sizeof (LONGEST) > sizeof (int))
1274 {
1275 if (rtnval != arg)
1276 {
8a3fe4f8 1277 error (_("Value out of range."));
c906108c
SS
1278 }
1279 }
1280 return (rtnval);
1281}
1282
a73c86fb
AC
1283/* Print a floating point value of type TYPE (not always a
1284 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
c906108c
SS
1285
1286void
fc1a4b47 1287print_floating (const gdb_byte *valaddr, struct type *type,
c84141d6 1288 struct ui_file *stream)
c906108c
SS
1289{
1290 DOUBLEST doub;
1291 int inv;
a73c86fb 1292 const struct floatformat *fmt = NULL;
c906108c 1293 unsigned len = TYPE_LENGTH (type);
20389057 1294 enum float_kind kind;
c5aa993b 1295
a73c86fb
AC
1296 /* If it is a floating-point, check for obvious problems. */
1297 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1298 fmt = floatformat_from_type (type);
20389057 1299 if (fmt != NULL)
39424bef 1300 {
20389057
DJ
1301 kind = floatformat_classify (fmt, valaddr);
1302 if (kind == float_nan)
1303 {
1304 if (floatformat_is_negative (fmt, valaddr))
1305 fprintf_filtered (stream, "-");
1306 fprintf_filtered (stream, "nan(");
1307 fputs_filtered ("0x", stream);
1308 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
1309 fprintf_filtered (stream, ")");
1310 return;
1311 }
1312 else if (kind == float_infinite)
1313 {
1314 if (floatformat_is_negative (fmt, valaddr))
1315 fputs_filtered ("-", stream);
1316 fputs_filtered ("inf", stream);
1317 return;
1318 }
7355ddba 1319 }
c906108c 1320
a73c86fb
AC
1321 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1322 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1323 needs to be used as that takes care of any necessary type
1324 conversions. Such conversions are of course direct to DOUBLEST
1325 and disregard any possible target floating point limitations.
1326 For instance, a u64 would be converted and displayed exactly on a
1327 host with 80 bit DOUBLEST but with loss of information on a host
1328 with 64 bit DOUBLEST. */
c2f05ac9 1329
c906108c
SS
1330 doub = unpack_double (type, valaddr, &inv);
1331 if (inv)
1332 {
1333 fprintf_filtered (stream, "<invalid float value>");
1334 return;
1335 }
1336
39424bef
MK
1337 /* FIXME: kettenis/2001-01-20: The following code makes too much
1338 assumptions about the host and target floating point format. */
1339
a73c86fb 1340 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
c41b8590 1341 not necessarily be a TYPE_CODE_FLT, the below ignores that and
a73c86fb
AC
1342 instead uses the type's length to determine the precision of the
1343 floating-point value being printed. */
c2f05ac9 1344
c906108c 1345 if (len < sizeof (double))
c5aa993b 1346 fprintf_filtered (stream, "%.9g", (double) doub);
c906108c 1347 else if (len == sizeof (double))
c5aa993b 1348 fprintf_filtered (stream, "%.17g", (double) doub);
c906108c
SS
1349 else
1350#ifdef PRINTF_HAS_LONG_DOUBLE
1351 fprintf_filtered (stream, "%.35Lg", doub);
1352#else
39424bef
MK
1353 /* This at least wins with values that are representable as
1354 doubles. */
c906108c
SS
1355 fprintf_filtered (stream, "%.17g", (double) doub);
1356#endif
1357}
1358
7678ef8f
TJB
1359void
1360print_decimal_floating (const gdb_byte *valaddr, struct type *type,
1361 struct ui_file *stream)
1362{
e17a4113 1363 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
7678ef8f
TJB
1364 char decstr[MAX_DECIMAL_STRING];
1365 unsigned len = TYPE_LENGTH (type);
1366
e17a4113 1367 decimal_to_string (valaddr, len, byte_order, decstr);
7678ef8f
TJB
1368 fputs_filtered (decstr, stream);
1369 return;
1370}
1371
c5aa993b 1372void
fc1a4b47 1373print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 1374 unsigned len, enum bfd_endian byte_order)
c906108c
SS
1375{
1376
1377#define BITS_IN_BYTES 8
1378
fc1a4b47 1379 const gdb_byte *p;
745b8ca0 1380 unsigned int i;
c5aa993b 1381 int b;
c906108c
SS
1382
1383 /* Declared "int" so it will be signed.
581e13c1
MS
1384 This ensures that right shift will shift in zeros. */
1385
c5aa993b 1386 const int mask = 0x080;
c906108c
SS
1387
1388 /* FIXME: We should be not printing leading zeroes in most cases. */
1389
d44e8473 1390 if (byte_order == BFD_ENDIAN_BIG)
c906108c
SS
1391 {
1392 for (p = valaddr;
1393 p < valaddr + len;
1394 p++)
1395 {
c5aa993b 1396 /* Every byte has 8 binary characters; peel off
581e13c1
MS
1397 and print from the MSB end. */
1398
c5aa993b
JM
1399 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1400 {
1401 if (*p & (mask >> i))
1402 b = 1;
1403 else
1404 b = 0;
1405
1406 fprintf_filtered (stream, "%1d", b);
1407 }
c906108c
SS
1408 }
1409 }
1410 else
1411 {
1412 for (p = valaddr + len - 1;
1413 p >= valaddr;
1414 p--)
1415 {
c5aa993b
JM
1416 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1417 {
1418 if (*p & (mask >> i))
1419 b = 1;
1420 else
1421 b = 0;
1422
1423 fprintf_filtered (stream, "%1d", b);
1424 }
c906108c
SS
1425 }
1426 }
c906108c
SS
1427}
1428
1429/* VALADDR points to an integer of LEN bytes.
581e13c1
MS
1430 Print it in octal on stream or format it in buf. */
1431
c906108c 1432void
fc1a4b47 1433print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 1434 unsigned len, enum bfd_endian byte_order)
c906108c 1435{
fc1a4b47 1436 const gdb_byte *p;
c906108c 1437 unsigned char octa1, octa2, octa3, carry;
c5aa993b
JM
1438 int cycle;
1439
c906108c
SS
1440 /* FIXME: We should be not printing leading zeroes in most cases. */
1441
1442
1443 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1444 * the extra bits, which cycle every three bytes:
1445 *
1446 * Byte side: 0 1 2 3
1447 * | | | |
1448 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1449 *
1450 * Octal side: 0 1 carry 3 4 carry ...
1451 *
1452 * Cycle number: 0 1 2
1453 *
1454 * But of course we are printing from the high side, so we have to
1455 * figure out where in the cycle we are so that we end up with no
1456 * left over bits at the end.
1457 */
1458#define BITS_IN_OCTAL 3
1459#define HIGH_ZERO 0340
1460#define LOW_ZERO 0016
1461#define CARRY_ZERO 0003
1462#define HIGH_ONE 0200
1463#define MID_ONE 0160
1464#define LOW_ONE 0016
1465#define CARRY_ONE 0001
1466#define HIGH_TWO 0300
1467#define MID_TWO 0070
1468#define LOW_TWO 0007
1469
1470 /* For 32 we start in cycle 2, with two bits and one bit carry;
581e13c1
MS
1471 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1472
c906108c
SS
1473 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
1474 carry = 0;
c5aa993b 1475
bb599908 1476 fputs_filtered ("0", stream);
d44e8473 1477 if (byte_order == BFD_ENDIAN_BIG)
c906108c
SS
1478 {
1479 for (p = valaddr;
1480 p < valaddr + len;
1481 p++)
1482 {
c5aa993b
JM
1483 switch (cycle)
1484 {
1485 case 0:
581e13c1
MS
1486 /* No carry in, carry out two bits. */
1487
c5aa993b
JM
1488 octa1 = (HIGH_ZERO & *p) >> 5;
1489 octa2 = (LOW_ZERO & *p) >> 2;
1490 carry = (CARRY_ZERO & *p);
1491 fprintf_filtered (stream, "%o", octa1);
1492 fprintf_filtered (stream, "%o", octa2);
1493 break;
1494
1495 case 1:
581e13c1
MS
1496 /* Carry in two bits, carry out one bit. */
1497
c5aa993b
JM
1498 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1499 octa2 = (MID_ONE & *p) >> 4;
1500 octa3 = (LOW_ONE & *p) >> 1;
1501 carry = (CARRY_ONE & *p);
1502 fprintf_filtered (stream, "%o", octa1);
1503 fprintf_filtered (stream, "%o", octa2);
1504 fprintf_filtered (stream, "%o", octa3);
1505 break;
1506
1507 case 2:
581e13c1
MS
1508 /* Carry in one bit, no carry out. */
1509
c5aa993b
JM
1510 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1511 octa2 = (MID_TWO & *p) >> 3;
1512 octa3 = (LOW_TWO & *p);
1513 carry = 0;
1514 fprintf_filtered (stream, "%o", octa1);
1515 fprintf_filtered (stream, "%o", octa2);
1516 fprintf_filtered (stream, "%o", octa3);
1517 break;
1518
1519 default:
8a3fe4f8 1520 error (_("Internal error in octal conversion;"));
c5aa993b
JM
1521 }
1522
1523 cycle++;
1524 cycle = cycle % BITS_IN_OCTAL;
c906108c
SS
1525 }
1526 }
1527 else
1528 {
1529 for (p = valaddr + len - 1;
1530 p >= valaddr;
1531 p--)
1532 {
c5aa993b
JM
1533 switch (cycle)
1534 {
1535 case 0:
1536 /* Carry out, no carry in */
581e13c1 1537
c5aa993b
JM
1538 octa1 = (HIGH_ZERO & *p) >> 5;
1539 octa2 = (LOW_ZERO & *p) >> 2;
1540 carry = (CARRY_ZERO & *p);
1541 fprintf_filtered (stream, "%o", octa1);
1542 fprintf_filtered (stream, "%o", octa2);
1543 break;
1544
1545 case 1:
1546 /* Carry in, carry out */
581e13c1 1547
c5aa993b
JM
1548 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1549 octa2 = (MID_ONE & *p) >> 4;
1550 octa3 = (LOW_ONE & *p) >> 1;
1551 carry = (CARRY_ONE & *p);
1552 fprintf_filtered (stream, "%o", octa1);
1553 fprintf_filtered (stream, "%o", octa2);
1554 fprintf_filtered (stream, "%o", octa3);
1555 break;
1556
1557 case 2:
1558 /* Carry in, no carry out */
581e13c1 1559
c5aa993b
JM
1560 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1561 octa2 = (MID_TWO & *p) >> 3;
1562 octa3 = (LOW_TWO & *p);
1563 carry = 0;
1564 fprintf_filtered (stream, "%o", octa1);
1565 fprintf_filtered (stream, "%o", octa2);
1566 fprintf_filtered (stream, "%o", octa3);
1567 break;
1568
1569 default:
8a3fe4f8 1570 error (_("Internal error in octal conversion;"));
c5aa993b
JM
1571 }
1572
1573 cycle++;
1574 cycle = cycle % BITS_IN_OCTAL;
c906108c
SS
1575 }
1576 }
1577
c906108c
SS
1578}
1579
1580/* VALADDR points to an integer of LEN bytes.
581e13c1
MS
1581 Print it in decimal on stream or format it in buf. */
1582
c906108c 1583void
fc1a4b47 1584print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 1585 unsigned len, enum bfd_endian byte_order)
c906108c
SS
1586{
1587#define TEN 10
c5aa993b 1588#define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
c906108c
SS
1589#define CARRY_LEFT( x ) ((x) % TEN)
1590#define SHIFT( x ) ((x) << 4)
c906108c
SS
1591#define LOW_NIBBLE( x ) ( (x) & 0x00F)
1592#define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1593
fc1a4b47 1594 const gdb_byte *p;
c906108c 1595 unsigned char *digits;
c5aa993b
JM
1596 int carry;
1597 int decimal_len;
1598 int i, j, decimal_digits;
1599 int dummy;
1600 int flip;
1601
c906108c 1602 /* Base-ten number is less than twice as many digits
581e13c1
MS
1603 as the base 16 number, which is 2 digits per byte. */
1604
c906108c 1605 decimal_len = len * 2 * 2;
3c37485b 1606 digits = xmalloc (decimal_len);
c906108c 1607
c5aa993b
JM
1608 for (i = 0; i < decimal_len; i++)
1609 {
c906108c 1610 digits[i] = 0;
c5aa993b 1611 }
c906108c 1612
c906108c
SS
1613 /* Ok, we have an unknown number of bytes of data to be printed in
1614 * decimal.
1615 *
1616 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1617 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1618 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1619 *
1620 * The trick is that "digits" holds a base-10 number, but sometimes
581e13c1 1621 * the individual digits are > 10.
c906108c
SS
1622 *
1623 * Outer loop is per nibble (hex digit) of input, from MSD end to
1624 * LSD end.
1625 */
c5aa993b 1626 decimal_digits = 0; /* Number of decimal digits so far */
d44e8473 1627 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
c906108c 1628 flip = 0;
d44e8473 1629 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
c5aa993b 1630 {
c906108c
SS
1631 /*
1632 * Multiply current base-ten number by 16 in place.
1633 * Each digit was between 0 and 9, now is between
1634 * 0 and 144.
1635 */
c5aa993b
JM
1636 for (j = 0; j < decimal_digits; j++)
1637 {
1638 digits[j] = SHIFT (digits[j]);
1639 }
1640
c906108c
SS
1641 /* Take the next nibble off the input and add it to what
1642 * we've got in the LSB position. Bottom 'digit' is now
1643 * between 0 and 159.
1644 *
1645 * "flip" is used to run this loop twice for each byte.
1646 */
c5aa993b
JM
1647 if (flip == 0)
1648 {
581e13c1
MS
1649 /* Take top nibble. */
1650
c5aa993b
JM
1651 digits[0] += HIGH_NIBBLE (*p);
1652 flip = 1;
1653 }
1654 else
1655 {
581e13c1
MS
1656 /* Take low nibble and bump our pointer "p". */
1657
c5aa993b 1658 digits[0] += LOW_NIBBLE (*p);
d44e8473
MD
1659 if (byte_order == BFD_ENDIAN_BIG)
1660 p++;
1661 else
1662 p--;
c5aa993b
JM
1663 flip = 0;
1664 }
c906108c
SS
1665
1666 /* Re-decimalize. We have to do this often enough
1667 * that we don't overflow, but once per nibble is
1668 * overkill. Easier this way, though. Note that the
1669 * carry is often larger than 10 (e.g. max initial
1670 * carry out of lowest nibble is 15, could bubble all
1671 * the way up greater than 10). So we have to do
1672 * the carrying beyond the last current digit.
1673 */
1674 carry = 0;
c5aa993b
JM
1675 for (j = 0; j < decimal_len - 1; j++)
1676 {
1677 digits[j] += carry;
1678
1679 /* "/" won't handle an unsigned char with
1680 * a value that if signed would be negative.
1681 * So extend to longword int via "dummy".
1682 */
1683 dummy = digits[j];
1684 carry = CARRY_OUT (dummy);
1685 digits[j] = CARRY_LEFT (dummy);
1686
1687 if (j >= decimal_digits && carry == 0)
1688 {
1689 /*
1690 * All higher digits are 0 and we
1691 * no longer have a carry.
1692 *
1693 * Note: "j" is 0-based, "decimal_digits" is
1694 * 1-based.
1695 */
1696 decimal_digits = j + 1;
1697 break;
1698 }
1699 }
1700 }
c906108c
SS
1701
1702 /* Ok, now "digits" is the decimal representation, with
581e13c1
MS
1703 the "decimal_digits" actual digits. Print! */
1704
c5aa993b
JM
1705 for (i = decimal_digits - 1; i >= 0; i--)
1706 {
1707 fprintf_filtered (stream, "%1d", digits[i]);
1708 }
b8c9b27d 1709 xfree (digits);
c906108c
SS
1710}
1711
1712/* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1713
6b9acc27 1714void
fc1a4b47 1715print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 1716 unsigned len, enum bfd_endian byte_order)
c906108c 1717{
fc1a4b47 1718 const gdb_byte *p;
c906108c
SS
1719
1720 /* FIXME: We should be not printing leading zeroes in most cases. */
1721
bb599908 1722 fputs_filtered ("0x", stream);
d44e8473 1723 if (byte_order == BFD_ENDIAN_BIG)
c906108c
SS
1724 {
1725 for (p = valaddr;
1726 p < valaddr + len;
1727 p++)
1728 {
1729 fprintf_filtered (stream, "%02x", *p);
1730 }
1731 }
1732 else
1733 {
1734 for (p = valaddr + len - 1;
1735 p >= valaddr;
1736 p--)
1737 {
1738 fprintf_filtered (stream, "%02x", *p);
1739 }
1740 }
c906108c
SS
1741}
1742
3e43a32a 1743/* VALADDR points to a char integer of LEN bytes.
581e13c1 1744 Print it out in appropriate language form on stream.
6b9acc27
JJ
1745 Omit any leading zero chars. */
1746
1747void
6c7a06a3
TT
1748print_char_chars (struct ui_file *stream, struct type *type,
1749 const gdb_byte *valaddr,
d44e8473 1750 unsigned len, enum bfd_endian byte_order)
6b9acc27 1751{
fc1a4b47 1752 const gdb_byte *p;
6b9acc27 1753
d44e8473 1754 if (byte_order == BFD_ENDIAN_BIG)
6b9acc27
JJ
1755 {
1756 p = valaddr;
1757 while (p < valaddr + len - 1 && *p == 0)
1758 ++p;
1759
1760 while (p < valaddr + len)
1761 {
6c7a06a3 1762 LA_EMIT_CHAR (*p, type, stream, '\'');
6b9acc27
JJ
1763 ++p;
1764 }
1765 }
1766 else
1767 {
1768 p = valaddr + len - 1;
1769 while (p > valaddr && *p == 0)
1770 --p;
1771
1772 while (p >= valaddr)
1773 {
6c7a06a3 1774 LA_EMIT_CHAR (*p, type, stream, '\'');
6b9acc27
JJ
1775 --p;
1776 }
1777 }
1778}
1779
132c57b4
TT
1780/* Print function pointer with inferior address ADDRESS onto stdio
1781 stream STREAM. */
1782
1783void
edf0c1b7
TT
1784print_function_pointer_address (const struct value_print_options *options,
1785 struct gdbarch *gdbarch,
132c57b4 1786 CORE_ADDR address,
edf0c1b7 1787 struct ui_file *stream)
132c57b4
TT
1788{
1789 CORE_ADDR func_addr
1790 = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
1791 &current_target);
1792
1793 /* If the function pointer is represented by a description, print
1794 the address of the description. */
edf0c1b7 1795 if (options->addressprint && func_addr != address)
132c57b4
TT
1796 {
1797 fputs_filtered ("@", stream);
1798 fputs_filtered (paddress (gdbarch, address), stream);
1799 fputs_filtered (": ", stream);
1800 }
edf0c1b7 1801 print_address_demangle (options, gdbarch, func_addr, stream, demangle);
132c57b4
TT
1802}
1803
1804
79a45b7d 1805/* Print on STREAM using the given OPTIONS the index for the element
e79af960
JB
1806 at INDEX of an array whose index type is INDEX_TYPE. */
1807
1808void
1809maybe_print_array_index (struct type *index_type, LONGEST index,
79a45b7d
TT
1810 struct ui_file *stream,
1811 const struct value_print_options *options)
e79af960
JB
1812{
1813 struct value *index_value;
1814
79a45b7d 1815 if (!options->print_array_indexes)
e79af960
JB
1816 return;
1817
1818 index_value = value_from_longest (index_type, index);
1819
79a45b7d
TT
1820 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1821}
e79af960 1822
c906108c 1823/* Called by various <lang>_val_print routines to print elements of an
c5aa993b 1824 array in the form "<elem1>, <elem2>, <elem3>, ...".
c906108c 1825
c5aa993b
JM
1826 (FIXME?) Assumes array element separator is a comma, which is correct
1827 for all languages currently handled.
1828 (FIXME?) Some languages have a notation for repeated array elements,
581e13c1 1829 perhaps we should try to use that notation when appropriate. */
c906108c
SS
1830
1831void
490f124f
PA
1832val_print_array_elements (struct type *type,
1833 const gdb_byte *valaddr, int embedded_offset,
a2bd3dcd 1834 CORE_ADDR address, struct ui_file *stream,
79a45b7d 1835 int recurse,
0e03807e 1836 const struct value *val,
79a45b7d 1837 const struct value_print_options *options,
fba45db2 1838 unsigned int i)
c906108c
SS
1839{
1840 unsigned int things_printed = 0;
1841 unsigned len;
aa715135 1842 struct type *elttype, *index_type, *base_index_type;
c906108c
SS
1843 unsigned eltlen;
1844 /* Position of the array element we are examining to see
1845 whether it is repeated. */
1846 unsigned int rep1;
1847 /* Number of repetitions we have detected so far. */
1848 unsigned int reps;
dbc98a8b 1849 LONGEST low_bound, high_bound;
aa715135 1850 LONGEST low_pos, high_pos;
c5aa993b 1851
c906108c 1852 elttype = TYPE_TARGET_TYPE (type);
3ae385af 1853 eltlen = type_length_units (check_typedef (elttype));
e79af960 1854 index_type = TYPE_INDEX_TYPE (type);
c906108c 1855
dbc98a8b 1856 if (get_array_bounds (type, &low_bound, &high_bound))
75be741b 1857 {
aa715135
JG
1858 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
1859 base_index_type = TYPE_TARGET_TYPE (index_type);
1860 else
1861 base_index_type = index_type;
1862
1863 /* Non-contiguous enumerations types can by used as index types
1864 in some languages (e.g. Ada). In this case, the array length
1865 shall be computed from the positions of the first and last
1866 literal in the enumeration type, and not from the values
1867 of these literals. */
1868 if (!discrete_position (base_index_type, low_bound, &low_pos)
1869 || !discrete_position (base_index_type, high_bound, &high_pos))
1870 {
1871 warning (_("unable to get positions in array, use bounds instead"));
1872 low_pos = low_bound;
1873 high_pos = high_bound;
1874 }
1875
1876 /* The array length should normally be HIGH_POS - LOW_POS + 1.
75be741b 1877 But we have to be a little extra careful, because some languages
aa715135 1878 such as Ada allow LOW_POS to be greater than HIGH_POS for
75be741b
JB
1879 empty arrays. In that situation, the array length is just zero,
1880 not negative! */
aa715135 1881 if (low_pos > high_pos)
75be741b
JB
1882 len = 0;
1883 else
aa715135 1884 len = high_pos - low_pos + 1;
75be741b 1885 }
e936309c
JB
1886 else
1887 {
dbc98a8b
KW
1888 warning (_("unable to get bounds of array, assuming null array"));
1889 low_bound = 0;
1890 len = 0;
168de233
JB
1891 }
1892
c906108c
SS
1893 annotate_array_section_begin (i, elttype);
1894
79a45b7d 1895 for (; i < len && things_printed < options->print_max; i++)
c906108c
SS
1896 {
1897 if (i != 0)
1898 {
2a998fc0 1899 if (options->prettyformat_arrays)
c906108c
SS
1900 {
1901 fprintf_filtered (stream, ",\n");
1902 print_spaces_filtered (2 + 2 * recurse, stream);
1903 }
1904 else
1905 {
1906 fprintf_filtered (stream, ", ");
1907 }
1908 }
1909 wrap_here (n_spaces (2 + 2 * recurse));
dbc98a8b 1910 maybe_print_array_index (index_type, i + low_bound,
79a45b7d 1911 stream, options);
c906108c
SS
1912
1913 rep1 = i + 1;
1914 reps = 1;
35bef4fd
TT
1915 /* Only check for reps if repeat_count_threshold is not set to
1916 UINT_MAX (unlimited). */
1917 if (options->repeat_count_threshold < UINT_MAX)
c906108c 1918 {
35bef4fd 1919 while (rep1 < len
9a0dc9e3
PA
1920 && value_contents_eq (val,
1921 embedded_offset + i * eltlen,
1922 val,
1923 (embedded_offset
1924 + rep1 * eltlen),
1925 eltlen))
35bef4fd
TT
1926 {
1927 ++reps;
1928 ++rep1;
1929 }
c906108c
SS
1930 }
1931
79a45b7d 1932 if (reps > options->repeat_count_threshold)
c906108c 1933 {
490f124f
PA
1934 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1935 address, stream, recurse + 1, val, options,
1936 current_language);
c906108c
SS
1937 annotate_elt_rep (reps);
1938 fprintf_filtered (stream, " <repeats %u times>", reps);
1939 annotate_elt_rep_end ();
1940
1941 i = rep1 - 1;
79a45b7d 1942 things_printed += options->repeat_count_threshold;
c906108c
SS
1943 }
1944 else
1945 {
490f124f
PA
1946 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1947 address,
0e03807e 1948 stream, recurse + 1, val, options, current_language);
c906108c
SS
1949 annotate_elt ();
1950 things_printed++;
1951 }
1952 }
1953 annotate_array_section_end ();
1954 if (i < len)
1955 {
1956 fprintf_filtered (stream, "...");
1957 }
1958}
1959
917317f4
JM
1960/* Read LEN bytes of target memory at address MEMADDR, placing the
1961 results in GDB's memory at MYADDR. Returns a count of the bytes
9b409511 1962 actually read, and optionally a target_xfer_status value in the
578d3588 1963 location pointed to by ERRPTR if ERRPTR is non-null. */
917317f4
JM
1964
1965/* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1966 function be eliminated. */
1967
1968static int
3e43a32a 1969partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
578d3588 1970 int len, int *errptr)
917317f4 1971{
581e13c1
MS
1972 int nread; /* Number of bytes actually read. */
1973 int errcode; /* Error from last read. */
917317f4 1974
581e13c1 1975 /* First try a complete read. */
917317f4
JM
1976 errcode = target_read_memory (memaddr, myaddr, len);
1977 if (errcode == 0)
1978 {
581e13c1 1979 /* Got it all. */
917317f4
JM
1980 nread = len;
1981 }
1982 else
1983 {
581e13c1 1984 /* Loop, reading one byte at a time until we get as much as we can. */
917317f4
JM
1985 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1986 {
1987 errcode = target_read_memory (memaddr++, myaddr++, 1);
1988 }
581e13c1 1989 /* If an error, the last read was unsuccessful, so adjust count. */
917317f4
JM
1990 if (errcode != 0)
1991 {
1992 nread--;
1993 }
1994 }
578d3588 1995 if (errptr != NULL)
917317f4 1996 {
578d3588 1997 *errptr = errcode;
917317f4
JM
1998 }
1999 return (nread);
2000}
2001
ae6a3a4c
TJB
2002/* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
2003 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
2004 allocated buffer containing the string, which the caller is responsible to
2005 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
9b409511 2006 success, or a target_xfer_status on failure.
ae6a3a4c 2007
f380848e
SA
2008 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
2009 (including eventual NULs in the middle or end of the string).
2010
2011 If LEN is -1, stops at the first null character (not necessarily
2012 the first null byte) up to a maximum of FETCHLIMIT characters. Set
2013 FETCHLIMIT to UINT_MAX to read as many characters as possible from
2014 the string.
ae6a3a4c
TJB
2015
2016 Unless an exception is thrown, BUFFER will always be allocated, even on
2017 failure. In this case, some characters might have been read before the
2018 failure happened. Check BYTES_READ to recognize this situation.
2019
2020 Note: There was a FIXME asking to make this code use target_read_string,
2021 but this function is more general (can read past null characters, up to
581e13c1 2022 given LEN). Besides, it is used much more often than target_read_string
ae6a3a4c
TJB
2023 so it is more tested. Perhaps callers of target_read_string should use
2024 this function instead? */
c906108c
SS
2025
2026int
ae6a3a4c 2027read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
e17a4113 2028 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
c906108c 2029{
ae6a3a4c
TJB
2030 int errcode; /* Errno returned from bad reads. */
2031 unsigned int nfetch; /* Chars to fetch / chars fetched. */
3e43a32a
MS
2032 gdb_byte *bufptr; /* Pointer to next available byte in
2033 buffer. */
ae6a3a4c
TJB
2034 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
2035
ae6a3a4c
TJB
2036 /* Loop until we either have all the characters, or we encounter
2037 some error, such as bumping into the end of the address space. */
c906108c 2038
b5096abe
PM
2039 *buffer = NULL;
2040
2041 old_chain = make_cleanup (free_current_contents, buffer);
c906108c
SS
2042
2043 if (len > 0)
2044 {
88db67ef
YQ
2045 /* We want fetchlimit chars, so we might as well read them all in
2046 one operation. */
f380848e
SA
2047 unsigned int fetchlen = min (len, fetchlimit);
2048
2049 *buffer = (gdb_byte *) xmalloc (fetchlen * width);
ae6a3a4c 2050 bufptr = *buffer;
c906108c 2051
f380848e 2052 nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
c906108c
SS
2053 / width;
2054 addr += nfetch * width;
2055 bufptr += nfetch * width;
2056 }
2057 else if (len == -1)
2058 {
2059 unsigned long bufsize = 0;
88db67ef
YQ
2060 unsigned int chunksize; /* Size of each fetch, in chars. */
2061 int found_nul; /* Non-zero if we found the nul char. */
2062 gdb_byte *limit; /* First location past end of fetch buffer. */
2063
2064 found_nul = 0;
2065 /* We are looking for a NUL terminator to end the fetching, so we
2066 might as well read in blocks that are large enough to be efficient,
2067 but not so large as to be slow if fetchlimit happens to be large.
2068 So we choose the minimum of 8 and fetchlimit. We used to use 200
2069 instead of 8 but 200 is way too big for remote debugging over a
2070 serial line. */
2071 chunksize = min (8, fetchlimit);
ae6a3a4c 2072
c906108c
SS
2073 do
2074 {
2075 QUIT;
2076 nfetch = min (chunksize, fetchlimit - bufsize);
2077
ae6a3a4c
TJB
2078 if (*buffer == NULL)
2079 *buffer = (gdb_byte *) xmalloc (nfetch * width);
c906108c 2080 else
b5096abe
PM
2081 *buffer = (gdb_byte *) xrealloc (*buffer,
2082 (nfetch + bufsize) * width);
c906108c 2083
ae6a3a4c 2084 bufptr = *buffer + bufsize * width;
c906108c
SS
2085 bufsize += nfetch;
2086
ae6a3a4c 2087 /* Read as much as we can. */
917317f4 2088 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
ae6a3a4c 2089 / width;
c906108c 2090
ae6a3a4c 2091 /* Scan this chunk for the null character that terminates the string
c906108c
SS
2092 to print. If found, we don't need to fetch any more. Note
2093 that bufptr is explicitly left pointing at the next character
ae6a3a4c
TJB
2094 after the null character, or at the next character after the end
2095 of the buffer. */
c906108c
SS
2096
2097 limit = bufptr + nfetch * width;
2098 while (bufptr < limit)
2099 {
2100 unsigned long c;
2101
e17a4113 2102 c = extract_unsigned_integer (bufptr, width, byte_order);
c906108c
SS
2103 addr += width;
2104 bufptr += width;
2105 if (c == 0)
2106 {
2107 /* We don't care about any error which happened after
ae6a3a4c 2108 the NUL terminator. */
c906108c
SS
2109 errcode = 0;
2110 found_nul = 1;
2111 break;
2112 }
2113 }
2114 }
c5aa993b 2115 while (errcode == 0 /* no error */
ae6a3a4c
TJB
2116 && bufptr - *buffer < fetchlimit * width /* no overrun */
2117 && !found_nul); /* haven't found NUL yet */
c906108c
SS
2118 }
2119 else
ae6a3a4c
TJB
2120 { /* Length of string is really 0! */
2121 /* We always allocate *buffer. */
2122 *buffer = bufptr = xmalloc (1);
c906108c
SS
2123 errcode = 0;
2124 }
2125
2126 /* bufptr and addr now point immediately beyond the last byte which we
2127 consider part of the string (including a '\0' which ends the string). */
ae6a3a4c
TJB
2128 *bytes_read = bufptr - *buffer;
2129
2130 QUIT;
2131
2132 discard_cleanups (old_chain);
2133
2134 return errcode;
2135}
2136
3b2b8fea
TT
2137/* Return true if print_wchar can display W without resorting to a
2138 numeric escape, false otherwise. */
2139
2140static int
2141wchar_printable (gdb_wchar_t w)
2142{
2143 return (gdb_iswprint (w)
2144 || w == LCST ('\a') || w == LCST ('\b')
2145 || w == LCST ('\f') || w == LCST ('\n')
2146 || w == LCST ('\r') || w == LCST ('\t')
2147 || w == LCST ('\v'));
2148}
2149
2150/* A helper function that converts the contents of STRING to wide
2151 characters and then appends them to OUTPUT. */
2152
2153static void
2154append_string_as_wide (const char *string,
2155 struct obstack *output)
2156{
2157 for (; *string; ++string)
2158 {
2159 gdb_wchar_t w = gdb_btowc (*string);
2160 obstack_grow (output, &w, sizeof (gdb_wchar_t));
2161 }
2162}
2163
2164/* Print a wide character W to OUTPUT. ORIG is a pointer to the
2165 original (target) bytes representing the character, ORIG_LEN is the
2166 number of valid bytes. WIDTH is the number of bytes in a base
2167 characters of the type. OUTPUT is an obstack to which wide
2168 characters are emitted. QUOTER is a (narrow) character indicating
2169 the style of quotes surrounding the character to be printed.
2170 NEED_ESCAPE is an in/out flag which is used to track numeric
2171 escapes across calls. */
2172
2173static void
2174print_wchar (gdb_wint_t w, const gdb_byte *orig,
2175 int orig_len, int width,
2176 enum bfd_endian byte_order,
2177 struct obstack *output,
2178 int quoter, int *need_escapep)
2179{
2180 int need_escape = *need_escapep;
2181
2182 *need_escapep = 0;
3b2b8fea 2183
95c64f92
YQ
2184 /* iswprint implementation on Windows returns 1 for tab character.
2185 In order to avoid different printout on this host, we explicitly
2186 use wchar_printable function. */
2187 switch (w)
3b2b8fea 2188 {
95c64f92
YQ
2189 case LCST ('\a'):
2190 obstack_grow_wstr (output, LCST ("\\a"));
2191 break;
2192 case LCST ('\b'):
2193 obstack_grow_wstr (output, LCST ("\\b"));
2194 break;
2195 case LCST ('\f'):
2196 obstack_grow_wstr (output, LCST ("\\f"));
2197 break;
2198 case LCST ('\n'):
2199 obstack_grow_wstr (output, LCST ("\\n"));
2200 break;
2201 case LCST ('\r'):
2202 obstack_grow_wstr (output, LCST ("\\r"));
2203 break;
2204 case LCST ('\t'):
2205 obstack_grow_wstr (output, LCST ("\\t"));
2206 break;
2207 case LCST ('\v'):
2208 obstack_grow_wstr (output, LCST ("\\v"));
2209 break;
2210 default:
3b2b8fea 2211 {
95c64f92
YQ
2212 if (wchar_printable (w) && (!need_escape || (!gdb_iswdigit (w)
2213 && w != LCST ('8')
2214 && w != LCST ('9'))))
2215 {
2216 gdb_wchar_t wchar = w;
3b2b8fea 2217
95c64f92
YQ
2218 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
2219 obstack_grow_wstr (output, LCST ("\\"));
2220 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
2221 }
2222 else
2223 {
2224 int i;
3b2b8fea 2225
95c64f92
YQ
2226 for (i = 0; i + width <= orig_len; i += width)
2227 {
2228 char octal[30];
2229 ULONGEST value;
2230
2231 value = extract_unsigned_integer (&orig[i], width,
3b2b8fea 2232 byte_order);
95c64f92
YQ
2233 /* If the value fits in 3 octal digits, print it that
2234 way. Otherwise, print it as a hex escape. */
2235 if (value <= 0777)
2236 xsnprintf (octal, sizeof (octal), "\\%.3o",
2237 (int) (value & 0777));
2238 else
2239 xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value);
2240 append_string_as_wide (octal, output);
2241 }
2242 /* If we somehow have extra bytes, print them now. */
2243 while (i < orig_len)
2244 {
2245 char octal[5];
2246
2247 xsnprintf (octal, sizeof (octal), "\\%.3o", orig[i] & 0xff);
2248 append_string_as_wide (octal, output);
2249 ++i;
2250 }
2251
2252 *need_escapep = 1;
2253 }
3b2b8fea
TT
2254 break;
2255 }
2256 }
2257}
2258
2259/* Print the character C on STREAM as part of the contents of a
2260 literal string whose delimiter is QUOTER. ENCODING names the
2261 encoding of C. */
2262
2263void
2264generic_emit_char (int c, struct type *type, struct ui_file *stream,
2265 int quoter, const char *encoding)
2266{
2267 enum bfd_endian byte_order
2268 = gdbarch_byte_order (get_type_arch (type));
2269 struct obstack wchar_buf, output;
2270 struct cleanup *cleanups;
2271 gdb_byte *buf;
2272 struct wchar_iterator *iter;
2273 int need_escape = 0;
2274
2275 buf = alloca (TYPE_LENGTH (type));
2276 pack_long (buf, type, c);
2277
2278 iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
2279 encoding, TYPE_LENGTH (type));
2280 cleanups = make_cleanup_wchar_iterator (iter);
2281
2282 /* This holds the printable form of the wchar_t data. */
2283 obstack_init (&wchar_buf);
2284 make_cleanup_obstack_free (&wchar_buf);
2285
2286 while (1)
2287 {
2288 int num_chars;
2289 gdb_wchar_t *chars;
2290 const gdb_byte *buf;
2291 size_t buflen;
2292 int print_escape = 1;
2293 enum wchar_iterate_result result;
2294
2295 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
2296 if (num_chars < 0)
2297 break;
2298 if (num_chars > 0)
2299 {
2300 /* If all characters are printable, print them. Otherwise,
2301 we're going to have to print an escape sequence. We
2302 check all characters because we want to print the target
2303 bytes in the escape sequence, and we don't know character
2304 boundaries there. */
2305 int i;
2306
2307 print_escape = 0;
2308 for (i = 0; i < num_chars; ++i)
2309 if (!wchar_printable (chars[i]))
2310 {
2311 print_escape = 1;
2312 break;
2313 }
2314
2315 if (!print_escape)
2316 {
2317 for (i = 0; i < num_chars; ++i)
2318 print_wchar (chars[i], buf, buflen,
2319 TYPE_LENGTH (type), byte_order,
2320 &wchar_buf, quoter, &need_escape);
2321 }
2322 }
2323
2324 /* This handles the NUM_CHARS == 0 case as well. */
2325 if (print_escape)
2326 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
2327 byte_order, &wchar_buf, quoter, &need_escape);
2328 }
2329
2330 /* The output in the host encoding. */
2331 obstack_init (&output);
2332 make_cleanup_obstack_free (&output);
2333
2334 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
ac91cd70 2335 (gdb_byte *) obstack_base (&wchar_buf),
3b2b8fea 2336 obstack_object_size (&wchar_buf),
fff10684 2337 sizeof (gdb_wchar_t), &output, translit_char);
3b2b8fea
TT
2338 obstack_1grow (&output, '\0');
2339
2340 fputs_filtered (obstack_base (&output), stream);
2341
2342 do_cleanups (cleanups);
2343}
2344
0d63ecda
KS
2345/* Return the repeat count of the next character/byte in ITER,
2346 storing the result in VEC. */
2347
2348static int
2349count_next_character (struct wchar_iterator *iter,
2350 VEC (converted_character_d) **vec)
2351{
2352 struct converted_character *current;
2353
2354 if (VEC_empty (converted_character_d, *vec))
2355 {
2356 struct converted_character tmp;
2357 gdb_wchar_t *chars;
2358
2359 tmp.num_chars
2360 = wchar_iterate (iter, &tmp.result, &chars, &tmp.buf, &tmp.buflen);
2361 if (tmp.num_chars > 0)
2362 {
2363 gdb_assert (tmp.num_chars < MAX_WCHARS);
2364 memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t));
2365 }
2366 VEC_safe_push (converted_character_d, *vec, &tmp);
2367 }
2368
2369 current = VEC_last (converted_character_d, *vec);
2370
2371 /* Count repeated characters or bytes. */
2372 current->repeat_count = 1;
2373 if (current->num_chars == -1)
2374 {
2375 /* EOF */
2376 return -1;
2377 }
2378 else
2379 {
2380 gdb_wchar_t *chars;
2381 struct converted_character d;
2382 int repeat;
2383
2384 d.repeat_count = 0;
2385
2386 while (1)
2387 {
2388 /* Get the next character. */
2389 d.num_chars
2390 = wchar_iterate (iter, &d.result, &chars, &d.buf, &d.buflen);
2391
2392 /* If a character was successfully converted, save the character
2393 into the converted character. */
2394 if (d.num_chars > 0)
2395 {
2396 gdb_assert (d.num_chars < MAX_WCHARS);
2397 memcpy (d.chars, chars, WCHAR_BUFLEN (d.num_chars));
2398 }
2399
2400 /* Determine if the current character is the same as this
2401 new character. */
2402 if (d.num_chars == current->num_chars && d.result == current->result)
2403 {
2404 /* There are two cases to consider:
2405
2406 1) Equality of converted character (num_chars > 0)
2407 2) Equality of non-converted character (num_chars == 0) */
2408 if ((current->num_chars > 0
2409 && memcmp (current->chars, d.chars,
2410 WCHAR_BUFLEN (current->num_chars)) == 0)
2411 || (current->num_chars == 0
2412 && current->buflen == d.buflen
2413 && memcmp (current->buf, d.buf, current->buflen) == 0))
2414 ++current->repeat_count;
2415 else
2416 break;
2417 }
2418 else
2419 break;
2420 }
2421
2422 /* Push this next converted character onto the result vector. */
2423 repeat = current->repeat_count;
2424 VEC_safe_push (converted_character_d, *vec, &d);
2425 return repeat;
2426 }
2427}
2428
2429/* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2430 character to use with string output. WIDTH is the size of the output
2431 character type. BYTE_ORDER is the the target byte order. OPTIONS
2432 is the user's print options. */
2433
2434static void
2435print_converted_chars_to_obstack (struct obstack *obstack,
2436 VEC (converted_character_d) *chars,
2437 int quote_char, int width,
2438 enum bfd_endian byte_order,
2439 const struct value_print_options *options)
2440{
2441 unsigned int idx;
2442 struct converted_character *elem;
2443 enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last;
2444 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
2445 int need_escape = 0;
2446
2447 /* Set the start state. */
2448 idx = 0;
2449 last = state = START;
2450 elem = NULL;
2451
2452 while (1)
2453 {
2454 switch (state)
2455 {
2456 case START:
2457 /* Nothing to do. */
2458 break;
2459
2460 case SINGLE:
2461 {
2462 int j;
2463
2464 /* We are outputting a single character
2465 (< options->repeat_count_threshold). */
2466
2467 if (last != SINGLE)
2468 {
2469 /* We were outputting some other type of content, so we
2470 must output and a comma and a quote. */
2471 if (last != START)
2472 obstack_grow_wstr (obstack, LCST (", "));
0d63ecda
KS
2473 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2474 }
2475 /* Output the character. */
2476 for (j = 0; j < elem->repeat_count; ++j)
2477 {
2478 if (elem->result == wchar_iterate_ok)
2479 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2480 byte_order, obstack, quote_char, &need_escape);
2481 else
2482 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2483 byte_order, obstack, quote_char, &need_escape);
2484 }
2485 }
2486 break;
2487
2488 case REPEAT:
2489 {
2490 int j;
2491 char *s;
2492
2493 /* We are outputting a character with a repeat count
2494 greater than options->repeat_count_threshold. */
2495
2496 if (last == SINGLE)
2497 {
2498 /* We were outputting a single string. Terminate the
2499 string. */
0d63ecda
KS
2500 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2501 }
2502 if (last != START)
2503 obstack_grow_wstr (obstack, LCST (", "));
2504
2505 /* Output the character and repeat string. */
2506 obstack_grow_wstr (obstack, LCST ("'"));
2507 if (elem->result == wchar_iterate_ok)
2508 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2509 byte_order, obstack, quote_char, &need_escape);
2510 else
2511 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2512 byte_order, obstack, quote_char, &need_escape);
2513 obstack_grow_wstr (obstack, LCST ("'"));
2514 s = xstrprintf (_(" <repeats %u times>"), elem->repeat_count);
2515 for (j = 0; s[j]; ++j)
2516 {
2517 gdb_wchar_t w = gdb_btowc (s[j]);
2518 obstack_grow (obstack, &w, sizeof (gdb_wchar_t));
2519 }
2520 xfree (s);
2521 }
2522 break;
2523
2524 case INCOMPLETE:
2525 /* We are outputting an incomplete sequence. */
2526 if (last == SINGLE)
2527 {
2528 /* If we were outputting a string of SINGLE characters,
2529 terminate the quote. */
0d63ecda
KS
2530 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2531 }
2532 if (last != START)
2533 obstack_grow_wstr (obstack, LCST (", "));
2534
2535 /* Output the incomplete sequence string. */
2536 obstack_grow_wstr (obstack, LCST ("<incomplete sequence "));
2537 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order,
2538 obstack, 0, &need_escape);
2539 obstack_grow_wstr (obstack, LCST (">"));
2540
2541 /* We do not attempt to outupt anything after this. */
2542 state = FINISH;
2543 break;
2544
2545 case FINISH:
2546 /* All done. If we were outputting a string of SINGLE
2547 characters, the string must be terminated. Otherwise,
2548 REPEAT and INCOMPLETE are always left properly terminated. */
2549 if (last == SINGLE)
e93a8774 2550 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
0d63ecda
KS
2551
2552 return;
2553 }
2554
2555 /* Get the next element and state. */
2556 last = state;
2557 if (state != FINISH)
2558 {
2559 elem = VEC_index (converted_character_d, chars, idx++);
2560 switch (elem->result)
2561 {
2562 case wchar_iterate_ok:
2563 case wchar_iterate_invalid:
2564 if (elem->repeat_count > options->repeat_count_threshold)
2565 state = REPEAT;
2566 else
2567 state = SINGLE;
2568 break;
2569
2570 case wchar_iterate_incomplete:
2571 state = INCOMPLETE;
2572 break;
2573
2574 case wchar_iterate_eof:
2575 state = FINISH;
2576 break;
2577 }
2578 }
2579 }
2580}
2581
3b2b8fea
TT
2582/* Print the character string STRING, printing at most LENGTH
2583 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2584 the type of each character. OPTIONS holds the printing options;
2585 printing stops early if the number hits print_max; repeat counts
2586 are printed as appropriate. Print ellipses at the end if we had to
2587 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2588 QUOTE_CHAR is the character to print at each end of the string. If
2589 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2590 omitted. */
2591
2592void
2593generic_printstr (struct ui_file *stream, struct type *type,
2594 const gdb_byte *string, unsigned int length,
2595 const char *encoding, int force_ellipses,
2596 int quote_char, int c_style_terminator,
2597 const struct value_print_options *options)
2598{
2599 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2600 unsigned int i;
3b2b8fea
TT
2601 int width = TYPE_LENGTH (type);
2602 struct obstack wchar_buf, output;
2603 struct cleanup *cleanup;
2604 struct wchar_iterator *iter;
2605 int finished = 0;
0d63ecda
KS
2606 struct converted_character *last;
2607 VEC (converted_character_d) *converted_chars;
3b2b8fea
TT
2608
2609 if (length == -1)
2610 {
2611 unsigned long current_char = 1;
2612
2613 for (i = 0; current_char; ++i)
2614 {
2615 QUIT;
2616 current_char = extract_unsigned_integer (string + i * width,
2617 width, byte_order);
2618 }
2619 length = i;
2620 }
2621
2622 /* If the string was not truncated due to `set print elements', and
2623 the last byte of it is a null, we don't print that, in
2624 traditional C style. */
2625 if (c_style_terminator
2626 && !force_ellipses
2627 && length > 0
2628 && (extract_unsigned_integer (string + (length - 1) * width,
2629 width, byte_order) == 0))
2630 length--;
2631
2632 if (length == 0)
2633 {
2634 fputs_filtered ("\"\"", stream);
2635 return;
2636 }
2637
2638 /* Arrange to iterate over the characters, in wchar_t form. */
2639 iter = make_wchar_iterator (string, length * width, encoding, width);
2640 cleanup = make_cleanup_wchar_iterator (iter);
0d63ecda
KS
2641 converted_chars = NULL;
2642 make_cleanup (VEC_cleanup (converted_character_d), &converted_chars);
3b2b8fea 2643
0d63ecda
KS
2644 /* Convert characters until the string is over or the maximum
2645 number of printed characters has been reached. */
2646 i = 0;
2647 while (i < options->print_max)
3b2b8fea 2648 {
0d63ecda 2649 int r;
3b2b8fea
TT
2650
2651 QUIT;
2652
0d63ecda
KS
2653 /* Grab the next character and repeat count. */
2654 r = count_next_character (iter, &converted_chars);
3b2b8fea 2655
0d63ecda
KS
2656 /* If less than zero, the end of the input string was reached. */
2657 if (r < 0)
2658 break;
3b2b8fea 2659
0d63ecda
KS
2660 /* Otherwise, add the count to the total print count and get
2661 the next character. */
2662 i += r;
2663 }
3b2b8fea 2664
0d63ecda
KS
2665 /* Get the last element and determine if the entire string was
2666 processed. */
2667 last = VEC_last (converted_character_d, converted_chars);
2668 finished = (last->result == wchar_iterate_eof);
3b2b8fea 2669
0d63ecda
KS
2670 /* Ensure that CONVERTED_CHARS is terminated. */
2671 last->result = wchar_iterate_eof;
3b2b8fea 2672
0d63ecda
KS
2673 /* WCHAR_BUF is the obstack we use to represent the string in
2674 wchar_t form. */
2675 obstack_init (&wchar_buf);
2676 make_cleanup_obstack_free (&wchar_buf);
3b2b8fea 2677
0d63ecda
KS
2678 /* Print the output string to the obstack. */
2679 print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char,
2680 width, byte_order, options);
3b2b8fea
TT
2681
2682 if (force_ellipses || !finished)
2683 obstack_grow_wstr (&wchar_buf, LCST ("..."));
2684
2685 /* OUTPUT is where we collect `char's for printing. */
2686 obstack_init (&output);
2687 make_cleanup_obstack_free (&output);
2688
2689 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
ac91cd70 2690 (gdb_byte *) obstack_base (&wchar_buf),
3b2b8fea 2691 obstack_object_size (&wchar_buf),
fff10684 2692 sizeof (gdb_wchar_t), &output, translit_char);
3b2b8fea
TT
2693 obstack_1grow (&output, '\0');
2694
2695 fputs_filtered (obstack_base (&output), stream);
2696
2697 do_cleanups (cleanup);
2698}
2699
ae6a3a4c
TJB
2700/* Print a string from the inferior, starting at ADDR and printing up to LEN
2701 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2702 stops at the first null byte, otherwise printing proceeds (including null
2703 bytes) until either print_max or LEN characters have been printed,
09ca9e2e
TT
2704 whichever is smaller. ENCODING is the name of the string's
2705 encoding. It can be NULL, in which case the target encoding is
2706 assumed. */
ae6a3a4c
TJB
2707
2708int
09ca9e2e
TT
2709val_print_string (struct type *elttype, const char *encoding,
2710 CORE_ADDR addr, int len,
6c7a06a3 2711 struct ui_file *stream,
ae6a3a4c
TJB
2712 const struct value_print_options *options)
2713{
2714 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
2715 int errcode; /* Errno returned from bad reads. */
581e13c1 2716 int found_nul; /* Non-zero if we found the nul char. */
ae6a3a4c
TJB
2717 unsigned int fetchlimit; /* Maximum number of chars to print. */
2718 int bytes_read;
2719 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
2720 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
5af949e3 2721 struct gdbarch *gdbarch = get_type_arch (elttype);
e17a4113 2722 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
6c7a06a3 2723 int width = TYPE_LENGTH (elttype);
ae6a3a4c
TJB
2724
2725 /* First we need to figure out the limit on the number of characters we are
2726 going to attempt to fetch and print. This is actually pretty simple. If
2727 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2728 LEN is -1, then the limit is print_max. This is true regardless of
2729 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2730 because finding the null byte (or available memory) is what actually
2731 limits the fetch. */
2732
3e43a32a
MS
2733 fetchlimit = (len == -1 ? options->print_max : min (len,
2734 options->print_max));
ae6a3a4c 2735
e17a4113
UW
2736 errcode = read_string (addr, len, width, fetchlimit, byte_order,
2737 &buffer, &bytes_read);
ae6a3a4c
TJB
2738 old_chain = make_cleanup (xfree, buffer);
2739
2740 addr += bytes_read;
c906108c 2741
3e43a32a
MS
2742 /* We now have either successfully filled the buffer to fetchlimit,
2743 or terminated early due to an error or finding a null char when
2744 LEN is -1. */
ae6a3a4c
TJB
2745
2746 /* Determine found_nul by looking at the last character read. */
6694c411
JK
2747 found_nul = 0;
2748 if (bytes_read >= width)
2749 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
2750 byte_order) == 0;
c906108c
SS
2751 if (len == -1 && !found_nul)
2752 {
777ea8f1 2753 gdb_byte *peekbuf;
c906108c 2754
ae6a3a4c 2755 /* We didn't find a NUL terminator we were looking for. Attempt
c5aa993b
JM
2756 to peek at the next character. If not successful, or it is not
2757 a null byte, then force ellipsis to be printed. */
c906108c 2758
777ea8f1 2759 peekbuf = (gdb_byte *) alloca (width);
c906108c
SS
2760
2761 if (target_read_memory (addr, peekbuf, width) == 0
e17a4113 2762 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
c906108c
SS
2763 force_ellipsis = 1;
2764 }
ae6a3a4c 2765 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
c906108c
SS
2766 {
2767 /* Getting an error when we have a requested length, or fetching less
c5aa993b 2768 than the number of characters actually requested, always make us
ae6a3a4c 2769 print ellipsis. */
c906108c
SS
2770 force_ellipsis = 1;
2771 }
2772
c906108c
SS
2773 /* If we get an error before fetching anything, don't print a string.
2774 But if we fetch something and then get an error, print the string
2775 and then the error message. */
ae6a3a4c 2776 if (errcode == 0 || bytes_read > 0)
c906108c 2777 {
be759fcf 2778 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
3a772aa4 2779 encoding, force_ellipsis, options);
c906108c
SS
2780 }
2781
2782 if (errcode != 0)
2783 {
578d3588
PA
2784 char *str;
2785
2786 str = memory_error_message (errcode, gdbarch, addr);
2787 make_cleanup (xfree, str);
2788
2789 fprintf_filtered (stream, "<error: ");
2790 fputs_filtered (str, stream);
2791 fprintf_filtered (stream, ">");
c906108c 2792 }
ae6a3a4c 2793
c906108c
SS
2794 gdb_flush (stream);
2795 do_cleanups (old_chain);
ae6a3a4c
TJB
2796
2797 return (bytes_read / width);
c906108c 2798}
c906108c 2799\f
c5aa993b 2800
09e6485f
PA
2801/* The 'set input-radix' command writes to this auxiliary variable.
2802 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2803 it is left unchanged. */
2804
2805static unsigned input_radix_1 = 10;
2806
c906108c
SS
2807/* Validate an input or output radix setting, and make sure the user
2808 knows what they really did here. Radix setting is confusing, e.g.
2809 setting the input radix to "10" never changes it! */
2810
c906108c 2811static void
fba45db2 2812set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
c906108c 2813{
09e6485f 2814 set_input_radix_1 (from_tty, input_radix_1);
c906108c
SS
2815}
2816
c906108c 2817static void
fba45db2 2818set_input_radix_1 (int from_tty, unsigned radix)
c906108c
SS
2819{
2820 /* We don't currently disallow any input radix except 0 or 1, which don't
2821 make any mathematical sense. In theory, we can deal with any input
2822 radix greater than 1, even if we don't have unique digits for every
2823 value from 0 to radix-1, but in practice we lose on large radix values.
2824 We should either fix the lossage or restrict the radix range more.
581e13c1 2825 (FIXME). */
c906108c
SS
2826
2827 if (radix < 2)
2828 {
09e6485f 2829 input_radix_1 = input_radix;
8a3fe4f8 2830 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
c906108c
SS
2831 radix);
2832 }
09e6485f 2833 input_radix_1 = input_radix = radix;
c906108c
SS
2834 if (from_tty)
2835 {
3e43a32a
MS
2836 printf_filtered (_("Input radix now set to "
2837 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
2838 radix, radix, radix);
2839 }
2840}
2841
09e6485f
PA
2842/* The 'set output-radix' command writes to this auxiliary variable.
2843 If the requested radix is valid, OUTPUT_RADIX is updated,
2844 otherwise, it is left unchanged. */
2845
2846static unsigned output_radix_1 = 10;
2847
c906108c 2848static void
fba45db2 2849set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
c906108c 2850{
09e6485f 2851 set_output_radix_1 (from_tty, output_radix_1);
c906108c
SS
2852}
2853
2854static void
fba45db2 2855set_output_radix_1 (int from_tty, unsigned radix)
c906108c
SS
2856{
2857 /* Validate the radix and disallow ones that we aren't prepared to
581e13c1 2858 handle correctly, leaving the radix unchanged. */
c906108c
SS
2859 switch (radix)
2860 {
2861 case 16:
79a45b7d 2862 user_print_options.output_format = 'x'; /* hex */
c906108c
SS
2863 break;
2864 case 10:
79a45b7d 2865 user_print_options.output_format = 0; /* decimal */
c906108c
SS
2866 break;
2867 case 8:
79a45b7d 2868 user_print_options.output_format = 'o'; /* octal */
c906108c
SS
2869 break;
2870 default:
09e6485f 2871 output_radix_1 = output_radix;
3e43a32a
MS
2872 error (_("Unsupported output radix ``decimal %u''; "
2873 "output radix unchanged."),
c906108c
SS
2874 radix);
2875 }
09e6485f 2876 output_radix_1 = output_radix = radix;
c906108c
SS
2877 if (from_tty)
2878 {
3e43a32a
MS
2879 printf_filtered (_("Output radix now set to "
2880 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
2881 radix, radix, radix);
2882 }
2883}
2884
2885/* Set both the input and output radix at once. Try to set the output radix
2886 first, since it has the most restrictive range. An radix that is valid as
2887 an output radix is also valid as an input radix.
2888
2889 It may be useful to have an unusual input radix. If the user wishes to
2890 set an input radix that is not valid as an output radix, he needs to use
581e13c1 2891 the 'set input-radix' command. */
c906108c
SS
2892
2893static void
fba45db2 2894set_radix (char *arg, int from_tty)
c906108c
SS
2895{
2896 unsigned radix;
2897
bb518678 2898 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
c906108c
SS
2899 set_output_radix_1 (0, radix);
2900 set_input_radix_1 (0, radix);
2901 if (from_tty)
2902 {
3e43a32a
MS
2903 printf_filtered (_("Input and output radices now set to "
2904 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
2905 radix, radix, radix);
2906 }
2907}
2908
581e13c1 2909/* Show both the input and output radices. */
c906108c 2910
c906108c 2911static void
fba45db2 2912show_radix (char *arg, int from_tty)
c906108c
SS
2913{
2914 if (from_tty)
2915 {
2916 if (input_radix == output_radix)
2917 {
3e43a32a
MS
2918 printf_filtered (_("Input and output radices set to "
2919 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
2920 input_radix, input_radix, input_radix);
2921 }
2922 else
2923 {
3e43a32a
MS
2924 printf_filtered (_("Input radix set to decimal "
2925 "%u, hex %x, octal %o.\n"),
c906108c 2926 input_radix, input_radix, input_radix);
3e43a32a
MS
2927 printf_filtered (_("Output radix set to decimal "
2928 "%u, hex %x, octal %o.\n"),
c906108c
SS
2929 output_radix, output_radix, output_radix);
2930 }
2931 }
2932}
c906108c 2933\f
c5aa993b 2934
c906108c 2935static void
fba45db2 2936set_print (char *arg, int from_tty)
c906108c
SS
2937{
2938 printf_unfiltered (
c5aa993b 2939 "\"set print\" must be followed by the name of a print subcommand.\n");
635c7e8a 2940 help_list (setprintlist, "set print ", all_commands, gdb_stdout);
c906108c
SS
2941}
2942
c906108c 2943static void
fba45db2 2944show_print (char *args, int from_tty)
c906108c
SS
2945{
2946 cmd_show_list (showprintlist, from_tty, "");
2947}
e7045703
DE
2948
2949static void
2950set_print_raw (char *arg, int from_tty)
2951{
2952 printf_unfiltered (
2953 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
635c7e8a 2954 help_list (setprintrawlist, "set print raw ", all_commands, gdb_stdout);
e7045703
DE
2955}
2956
2957static void
2958show_print_raw (char *args, int from_tty)
2959{
2960 cmd_show_list (showprintrawlist, from_tty, "");
2961}
2962
c906108c
SS
2963\f
2964void
fba45db2 2965_initialize_valprint (void)
c906108c 2966{
c906108c 2967 add_prefix_cmd ("print", no_class, set_print,
1bedd215 2968 _("Generic command for setting how things print."),
c906108c 2969 &setprintlist, "set print ", 0, &setlist);
c5aa993b 2970 add_alias_cmd ("p", "print", no_class, 1, &setlist);
581e13c1 2971 /* Prefer set print to set prompt. */
c906108c
SS
2972 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
2973
2974 add_prefix_cmd ("print", no_class, show_print,
1bedd215 2975 _("Generic command for showing print settings."),
c906108c 2976 &showprintlist, "show print ", 0, &showlist);
c5aa993b
JM
2977 add_alias_cmd ("p", "print", no_class, 1, &showlist);
2978 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
c906108c 2979
e7045703
DE
2980 add_prefix_cmd ("raw", no_class, set_print_raw,
2981 _("\
2982Generic command for setting what things to print in \"raw\" mode."),
2983 &setprintrawlist, "set print raw ", 0, &setprintlist);
2984 add_prefix_cmd ("raw", no_class, show_print_raw,
2985 _("Generic command for showing \"print raw\" settings."),
2986 &showprintrawlist, "show print raw ", 0, &showprintlist);
2987
79a45b7d
TT
2988 add_setshow_uinteger_cmd ("elements", no_class,
2989 &user_print_options.print_max, _("\
35096d9d
AC
2990Set limit on string chars or array elements to print."), _("\
2991Show limit on string chars or array elements to print."), _("\
f81d1120 2992\"set print elements unlimited\" causes there to be no limit."),
35096d9d 2993 NULL,
920d2a44 2994 show_print_max,
35096d9d 2995 &setprintlist, &showprintlist);
c906108c 2996
79a45b7d
TT
2997 add_setshow_boolean_cmd ("null-stop", no_class,
2998 &user_print_options.stop_print_at_null, _("\
5bf193a2
AC
2999Set printing of char arrays to stop at first null char."), _("\
3000Show printing of char arrays to stop at first null char."), NULL,
3001 NULL,
920d2a44 3002 show_stop_print_at_null,
5bf193a2 3003 &setprintlist, &showprintlist);
c906108c 3004
35096d9d 3005 add_setshow_uinteger_cmd ("repeats", no_class,
79a45b7d 3006 &user_print_options.repeat_count_threshold, _("\
35096d9d
AC
3007Set threshold for repeated print elements."), _("\
3008Show threshold for repeated print elements."), _("\
f81d1120 3009\"set print repeats unlimited\" causes all elements to be individually printed."),
35096d9d 3010 NULL,
920d2a44 3011 show_repeat_count_threshold,
35096d9d 3012 &setprintlist, &showprintlist);
c906108c 3013
79a45b7d 3014 add_setshow_boolean_cmd ("pretty", class_support,
2a998fc0
DE
3015 &user_print_options.prettyformat_structs, _("\
3016Set pretty formatting of structures."), _("\
3017Show pretty formatting of structures."), NULL,
5bf193a2 3018 NULL,
2a998fc0 3019 show_prettyformat_structs,
5bf193a2
AC
3020 &setprintlist, &showprintlist);
3021
79a45b7d
TT
3022 add_setshow_boolean_cmd ("union", class_support,
3023 &user_print_options.unionprint, _("\
5bf193a2
AC
3024Set printing of unions interior to structures."), _("\
3025Show printing of unions interior to structures."), NULL,
3026 NULL,
920d2a44 3027 show_unionprint,
5bf193a2
AC
3028 &setprintlist, &showprintlist);
3029
79a45b7d 3030 add_setshow_boolean_cmd ("array", class_support,
2a998fc0
DE
3031 &user_print_options.prettyformat_arrays, _("\
3032Set pretty formatting of arrays."), _("\
3033Show pretty formatting of arrays."), NULL,
5bf193a2 3034 NULL,
2a998fc0 3035 show_prettyformat_arrays,
5bf193a2
AC
3036 &setprintlist, &showprintlist);
3037
79a45b7d
TT
3038 add_setshow_boolean_cmd ("address", class_support,
3039 &user_print_options.addressprint, _("\
5bf193a2
AC
3040Set printing of addresses."), _("\
3041Show printing of addresses."), NULL,
3042 NULL,
920d2a44 3043 show_addressprint,
5bf193a2 3044 &setprintlist, &showprintlist);
c906108c 3045
9cb709b6
TT
3046 add_setshow_boolean_cmd ("symbol", class_support,
3047 &user_print_options.symbol_print, _("\
3048Set printing of symbol names when printing pointers."), _("\
3049Show printing of symbol names when printing pointers."),
3050 NULL, NULL,
3051 show_symbol_print,
3052 &setprintlist, &showprintlist);
3053
1e8fb976
PA
3054 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
3055 _("\
35096d9d
AC
3056Set default input radix for entering numbers."), _("\
3057Show default input radix for entering numbers."), NULL,
1e8fb976
PA
3058 set_input_radix,
3059 show_input_radix,
3060 &setlist, &showlist);
35096d9d 3061
1e8fb976
PA
3062 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
3063 _("\
35096d9d
AC
3064Set default output radix for printing of values."), _("\
3065Show default output radix for printing of values."), NULL,
1e8fb976
PA
3066 set_output_radix,
3067 show_output_radix,
3068 &setlist, &showlist);
c906108c 3069
cb1a6d5f
AC
3070 /* The "set radix" and "show radix" commands are special in that
3071 they are like normal set and show commands but allow two normally
3072 independent variables to be either set or shown with a single
b66df561 3073 command. So the usual deprecated_add_set_cmd() and [deleted]
581e13c1 3074 add_show_from_set() commands aren't really appropriate. */
b66df561
AC
3075 /* FIXME: i18n: With the new add_setshow_integer command, that is no
3076 longer true - show can display anything. */
1a966eab
AC
3077 add_cmd ("radix", class_support, set_radix, _("\
3078Set default input and output number radices.\n\
c906108c 3079Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1a966eab 3080Without an argument, sets both radices back to the default value of 10."),
c906108c 3081 &setlist);
1a966eab
AC
3082 add_cmd ("radix", class_support, show_radix, _("\
3083Show the default input and output number radices.\n\
3084Use 'show input-radix' or 'show output-radix' to independently show each."),
c906108c
SS
3085 &showlist);
3086
e79af960 3087 add_setshow_boolean_cmd ("array-indexes", class_support,
79a45b7d 3088 &user_print_options.print_array_indexes, _("\
e79af960
JB
3089Set printing of array indexes."), _("\
3090Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
3091 &setprintlist, &showprintlist);
c906108c 3092}
This page took 1.838395 seconds and 4 git commands to generate.