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