1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description */
24 #include "expression.h"
33 #include "typeprint.h"
37 static int print_selected_record_field_types (struct type *, struct type *,
39 struct ui_file *, int, int,
40 const struct type_print_options *);
42 static int print_record_field_types (struct type *, struct type *,
43 struct ui_file *, int, int,
44 const struct type_print_options *);
48 static char *name_buffer;
49 static int name_buffer_len;
51 /* The (decoded) Ada name of TYPE. This value persists until the
55 decoded_type_name (struct type *type)
57 if (ada_type_name (type) == NULL)
61 const char *raw_name = ada_type_name (type);
64 if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
66 name_buffer_len = 16 + 2 * strlen (raw_name);
67 name_buffer = xrealloc (name_buffer, name_buffer_len);
69 strcpy (name_buffer, raw_name);
71 s = (char *) strstr (name_buffer, "___");
75 s = name_buffer + strlen (name_buffer) - 1;
76 while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
85 for (s = q = name_buffer; *s != '\0'; q += 1)
87 if (s[0] == '_' && s[1] == '_')
103 /* Return nonzero if TYPE is a subrange type, and its bounds
104 are identical to the bounds of its subtype. */
107 type_is_full_subrange_of_target_type (struct type *type)
109 struct type *subtype;
111 if (TYPE_CODE (type) != TYPE_CODE_RANGE)
114 subtype = TYPE_TARGET_TYPE (type);
118 if (is_dynamic_type (type))
121 if (ada_discrete_type_low_bound (type)
122 != ada_discrete_type_low_bound (subtype))
125 if (ada_discrete_type_high_bound (type)
126 != ada_discrete_type_high_bound (subtype))
132 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
136 print_range (struct type *type, struct ui_file *stream,
137 int bounds_prefered_p)
139 if (!bounds_prefered_p)
141 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
142 are identical to the bounds of their subtype. When
143 the bounds of both types match, it can allow us to
144 print a range using the name of its base type, which
145 is easier to read. For instance, we would print...
147 array (character) of ...
151 array ('["00"]' .. '["ff"]') of ... */
152 while (type_is_full_subrange_of_target_type (type))
153 type = TYPE_TARGET_TYPE (type);
156 switch (TYPE_CODE (type))
158 case TYPE_CODE_RANGE:
161 struct type *target_type;
162 volatile struct gdb_exception e;
163 LONGEST lo = 0, hi = 0; /* init for gcc -Wall */
165 target_type = TYPE_TARGET_TYPE (type);
166 if (target_type == NULL)
169 TRY_CATCH (e, RETURN_MASK_ERROR)
171 lo = ada_discrete_type_low_bound (type);
172 hi = ada_discrete_type_high_bound (type);
176 /* This can happen when the range is dynamic. Sometimes,
177 resolving dynamic property values requires us to have
178 access to an actual object, which is not available
179 when the user is using the "ptype" command on a type.
180 Print the range as an unbounded range. */
181 fprintf_filtered (stream, "<>");
185 ada_print_scalar (target_type, lo, stream);
186 fprintf_filtered (stream, " .. ");
187 ada_print_scalar (target_type, hi, stream);
192 fprintf_filtered (stream, "%.*s",
193 ada_name_prefix_len (TYPE_NAME (type)),
199 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
200 set *N past the bound and its delimiter, if any. */
203 print_range_bound (struct type *type, char *bounds, int *n,
204 struct ui_file *stream)
208 if (ada_scan_number (bounds, *n, &B, n))
210 /* STABS decodes all range types which bounds are 0 .. -1 as
211 unsigned integers (ie. the type code is TYPE_CODE_INT, not
212 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
213 on the unsigned flag to determine whether the bound should
214 be printed as a signed or an unsigned value. This causes
215 the upper bound of the 0 .. -1 range types to be printed as
216 a very large unsigned number instead of -1.
217 To workaround this stabs deficiency, we replace the TYPE by NULL
218 to indicate default output when we detect that the bound is negative,
219 and the type is a TYPE_CODE_INT. The bound is negative when
220 'm' is the last character of the number scanned in BOUNDS. */
221 if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
223 ada_print_scalar (type, B, stream);
224 if (bounds[*n] == '_')
230 char *bound = bounds + *n;
233 pend = strstr (bound, "__");
235 *n += bound_len = strlen (bound);
238 bound_len = pend - bound;
241 fprintf_filtered (stream, "%.*s", bound_len, bound);
245 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
246 the value (if found) of the bound indicated by SUFFIX ("___L" or
247 "___U") according to the ___XD conventions. */
250 print_dynamic_range_bound (struct type *type, const char *name, int name_len,
251 const char *suffix, struct ui_file *stream)
253 static char *name_buf = NULL;
254 static size_t name_buf_len = 0;
258 GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
259 strncpy (name_buf, name, name_len);
260 strcpy (name_buf + name_len, suffix);
262 B = get_int_var_value (name_buf, &OK);
264 ada_print_scalar (type, B, stream);
266 fprintf_filtered (stream, "?");
269 /* Print RAW_TYPE as a range type, using any bound information
270 following the GNAT encoding (if available).
272 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
273 using its bounds. Otherwise, try printing the range without
274 printing the value of the bounds, if possible (this is only
275 considered a hint, not a guaranty). */
278 print_range_type (struct type *raw_type, struct ui_file *stream,
279 int bounds_prefered_p)
282 struct type *base_type;
283 const char *subtype_info;
285 gdb_assert (raw_type != NULL);
286 name = TYPE_NAME (raw_type);
287 gdb_assert (name != NULL);
289 if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
290 base_type = TYPE_TARGET_TYPE (raw_type);
292 base_type = raw_type;
294 subtype_info = strstr (name, "___XD");
295 if (subtype_info == NULL)
296 print_range (raw_type, stream, bounds_prefered_p);
299 int prefix_len = subtype_info - name;
304 bounds_str = strchr (subtype_info, '_');
307 if (*subtype_info == 'L')
309 print_range_bound (base_type, bounds_str, &n, stream);
313 print_dynamic_range_bound (base_type, name, prefix_len, "___L",
316 fprintf_filtered (stream, " .. ");
318 if (*subtype_info == 'U')
319 print_range_bound (base_type, bounds_str, &n, stream);
321 print_dynamic_range_bound (base_type, name, prefix_len, "___U",
326 /* Print enumerated type TYPE on STREAM. */
329 print_enum_type (struct type *type, struct ui_file *stream)
331 int len = TYPE_NFIELDS (type);
335 fprintf_filtered (stream, "(");
339 for (i = 0; i < len; i++)
343 fprintf_filtered (stream, ", ");
345 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
346 if (lastval != TYPE_FIELD_ENUMVAL (type, i))
348 fprintf_filtered (stream, " => %s",
349 plongest (TYPE_FIELD_ENUMVAL (type, i)));
350 lastval = TYPE_FIELD_ENUMVAL (type, i);
354 fprintf_filtered (stream, ")");
357 /* Print representation of Ada fixed-point type TYPE on STREAM. */
360 print_fixed_point_type (struct type *type, struct ui_file *stream)
362 DOUBLEST delta = ada_delta (type);
363 DOUBLEST small = ada_fixed_to_float (type, 1.0);
366 fprintf_filtered (stream, "delta ??");
369 fprintf_filtered (stream, "delta %g", (double) delta);
371 fprintf_filtered (stream, " <'small = %g>", (double) small);
375 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
376 recursion (indentation) level, in case the element type itself has
377 nested structure, and SHOW is the number of levels of internal
378 structure to show (see ada_print_type). */
381 print_array_type (struct type *type, struct ui_file *stream, int show,
382 int level, const struct type_print_options *flags)
387 if (ada_is_constrained_packed_array_type (type))
388 type = ada_coerce_to_simple_array_type (type);
391 fprintf_filtered (stream, "array (");
395 fprintf_filtered (stream, _("<undecipherable array type>"));
400 if (ada_is_simple_array_type (type))
402 struct type *range_desc_type;
403 struct type *arr_type;
405 range_desc_type = ada_find_parallel_type (type, "___XA");
406 ada_fixup_array_indexes_type (range_desc_type);
409 if (range_desc_type == NULL)
411 for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
412 arr_type = TYPE_TARGET_TYPE (arr_type))
414 if (arr_type != type)
415 fprintf_filtered (stream, ", ");
416 print_range (TYPE_INDEX_TYPE (arr_type), stream,
417 0 /* bounds_prefered_p */);
418 if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
419 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
426 n_indices = TYPE_NFIELDS (range_desc_type);
427 for (k = 0, arr_type = type;
429 k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
432 fprintf_filtered (stream, ", ");
433 print_range_type (TYPE_FIELD_TYPE (range_desc_type, k),
434 stream, 0 /* bounds_prefered_p */);
435 if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
436 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
444 for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
445 fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
448 fprintf_filtered (stream, ") of ");
450 ada_print_type (ada_array_element_type (type, n_indices), "", stream,
451 show == 0 ? 0 : show - 1, level + 1, flags);
453 fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
456 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
457 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
458 values. Return non-zero if the field is an encoding of
459 discriminant values, as in a standard variant record, and 0 if the
460 field is not so encoded (as happens with single-component variants
461 in types annotated with pragma Unchecked_Variant). */
464 print_choices (struct type *type, int field_num, struct ui_file *stream,
465 struct type *val_type)
469 const char *name = TYPE_FIELD_NAME (type, field_num);
473 /* Skip over leading 'V': NOTE soon to be obsolete. */
476 if (!ada_scan_number (name, 1, NULL, &p))
490 fprintf_filtered (stream, " =>");
496 fprintf_filtered (stream, " | ");
507 if (!ada_scan_number (name, p + 1, &W, &p))
509 ada_print_scalar (val_type, W, stream);
516 if (!ada_scan_number (name, p + 1, &L, &p)
517 || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
519 ada_print_scalar (val_type, L, stream);
520 fprintf_filtered (stream, " .. ");
521 ada_print_scalar (val_type, U, stream);
525 fprintf_filtered (stream, "others");
532 fprintf_filtered (stream, "?? =>");
536 /* Assuming that field FIELD_NUM of TYPE represents variants whose
537 discriminant is contained in OUTER_TYPE, print its components on STREAM.
538 LEVEL is the recursion (indentation) level, in case any of the fields
539 themselves have nested structure, and SHOW is the number of levels of
540 internal structure to show (see ada_print_type). For this purpose,
541 fields nested in a variant part are taken to be at the same level as
542 the fields immediately outside the variant part. */
545 print_variant_clauses (struct type *type, int field_num,
546 struct type *outer_type, struct ui_file *stream,
548 const struct type_print_options *flags)
551 struct type *var_type, *par_type;
552 struct type *discr_type;
554 var_type = TYPE_FIELD_TYPE (type, field_num);
555 discr_type = ada_variant_discrim_type (var_type, outer_type);
557 if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
559 var_type = TYPE_TARGET_TYPE (var_type);
560 if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
564 par_type = ada_find_parallel_type (var_type, "___XVU");
565 if (par_type != NULL)
568 for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
570 fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
571 if (print_choices (var_type, i, stream, discr_type))
573 if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
574 outer_type, stream, show, level + 4,
577 fprintf_filtered (stream, " null;");
580 print_selected_record_field_types (var_type, outer_type, i, i,
581 stream, show, level + 4, flags);
585 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
586 discriminants are contained in OUTER_TYPE, print a description of it
587 on STREAM. LEVEL is the recursion (indentation) level, in case any of
588 the fields themselves have nested structure, and SHOW is the number of
589 levels of internal structure to show (see ada_print_type). For this
590 purpose, fields nested in a variant part are taken to be at the same
591 level as the fields immediately outside the variant part. */
594 print_variant_part (struct type *type, int field_num, struct type *outer_type,
595 struct ui_file *stream, int show, int level,
596 const struct type_print_options *flags)
598 fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
599 ada_variant_discrim_name
600 (TYPE_FIELD_TYPE (type, field_num)));
601 print_variant_clauses (type, field_num, outer_type, stream, show,
603 fprintf_filtered (stream, "\n%*send case;", level + 4, "");
606 /* Print a description on STREAM of the fields FLD0 through FLD1 in
607 record or union type TYPE, whose discriminants are in OUTER_TYPE.
608 LEVEL is the recursion (indentation) level, in case any of the
609 fields themselves have nested structure, and SHOW is the number of
610 levels of internal structure to show (see ada_print_type). Does
611 not print parent type information of TYPE. Returns 0 if no fields
612 printed, -1 for an incomplete type, else > 0. Prints each field
613 beginning on a new line, but does not put a new line at end. */
616 print_selected_record_field_types (struct type *type, struct type *outer_type,
618 struct ui_file *stream, int show, int level,
619 const struct type_print_options *flags)
625 if (fld0 > fld1 && TYPE_STUB (type))
628 for (i = fld0; i <= fld1; i += 1)
632 if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
634 else if (ada_is_wrapper_field (type, i))
635 flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
636 stream, show, level, flags);
637 else if (ada_is_variant_part (type, i))
639 print_variant_part (type, i, outer_type, stream, show, level, flags);
645 fprintf_filtered (stream, "\n%*s", level + 4, "");
646 ada_print_type (TYPE_FIELD_TYPE (type, i),
647 TYPE_FIELD_NAME (type, i),
648 stream, show - 1, level + 4, flags);
649 fprintf_filtered (stream, ";");
656 /* Print a description on STREAM of all fields of record or union type
657 TYPE, as for print_selected_record_field_types, above. */
660 print_record_field_types (struct type *type, struct type *outer_type,
661 struct ui_file *stream, int show, int level,
662 const struct type_print_options *flags)
664 return print_selected_record_field_types (type, outer_type,
665 0, TYPE_NFIELDS (type) - 1,
666 stream, show, level, flags);
670 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
671 level, in case the element type itself has nested structure, and SHOW is
672 the number of levels of internal structure to show (see ada_print_type). */
675 print_record_type (struct type *type0, struct ui_file *stream, int show,
676 int level, const struct type_print_options *flags)
678 struct type *parent_type;
681 type = ada_find_parallel_type (type0, "___XVE");
685 parent_type = ada_parent_type (type);
686 if (ada_type_name (parent_type) != NULL)
688 const char *parent_name = decoded_type_name (parent_type);
690 /* If we fail to decode the parent type name, then use the parent
691 type name as is. Not pretty, but should never happen except
692 when the debugging info is incomplete or incorrect. This
693 prevents a crash trying to print a NULL pointer. */
694 if (parent_name == NULL)
695 parent_name = ada_type_name (parent_type);
696 fprintf_filtered (stream, "new %s with record", parent_name);
698 else if (parent_type == NULL && ada_is_tagged_type (type, 0))
699 fprintf_filtered (stream, "tagged record");
701 fprintf_filtered (stream, "record");
704 fprintf_filtered (stream, " ... end record");
710 if (parent_type != NULL && ada_type_name (parent_type) == NULL)
711 flds += print_record_field_types (parent_type, parent_type,
712 stream, show, level, flags);
713 flds += print_record_field_types (type, type, stream, show, level,
717 fprintf_filtered (stream, "\n%*send record", level, "");
719 fprintf_filtered (stream, _(" <incomplete type> end record"));
721 fprintf_filtered (stream, " null; end record");
725 /* Print the unchecked union type TYPE in something resembling Ada
726 format on STREAM. LEVEL is the recursion (indentation) level
727 in case the element type itself has nested structure, and SHOW is the
728 number of levels of internal structure to show (see ada_print_type). */
730 print_unchecked_union_type (struct type *type, struct ui_file *stream,
732 const struct type_print_options *flags)
735 fprintf_filtered (stream, "record (?) is ... end record");
736 else if (TYPE_NFIELDS (type) == 0)
737 fprintf_filtered (stream, "record (?) is null; end record");
742 fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
744 for (i = 0; i < TYPE_NFIELDS (type); i += 1)
746 fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
748 ada_print_type (TYPE_FIELD_TYPE (type, i),
749 TYPE_FIELD_NAME (type, i),
750 stream, show - 1, level + 12, flags);
751 fprintf_filtered (stream, ";");
754 fprintf_filtered (stream, "\n%*send case;\n%*send record",
755 level + 4, "", level, "");
761 /* Print function or procedure type TYPE on STREAM. Make it a header
762 for function or procedure NAME if NAME is not null. */
765 print_func_type (struct type *type, struct ui_file *stream, const char *name,
766 const struct type_print_options *flags)
768 int i, len = TYPE_NFIELDS (type);
770 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
771 fprintf_filtered (stream, "procedure");
773 fprintf_filtered (stream, "function");
775 if (name != NULL && name[0] != '\0')
776 fprintf_filtered (stream, " %s", name);
780 fprintf_filtered (stream, " (");
781 for (i = 0; i < len; i += 1)
785 fputs_filtered ("; ", stream);
788 fprintf_filtered (stream, "a%d: ", i + 1);
789 ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0,
792 fprintf_filtered (stream, ")");
795 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
797 fprintf_filtered (stream, " return ");
798 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
803 /* Print a description of a type TYPE0.
804 Output goes to STREAM (via stdio).
805 If VARSTRING is a non-empty string, print as an Ada variable/field
807 SHOW+1 is the maximum number of levels of internal type structure
808 to show (this applies to record types, enumerated types, and
810 SHOW is the number of levels of internal type structure to show
811 when there is a type name for the SHOWth deepest level (0th is
813 When SHOW<0, no inner structure is shown.
814 LEVEL indicates level of recursion (for nested definitions). */
817 ada_print_type (struct type *type0, const char *varstring,
818 struct ui_file *stream, int show, int level,
819 const struct type_print_options *flags)
821 struct type *type = ada_check_typedef (ada_get_base_type (type0));
822 char *type_name = decoded_type_name (type0);
823 int is_var_decl = (varstring != NULL && varstring[0] != '\0');
828 fprintf_filtered (stream, "%.*s: ",
829 ada_name_prefix_len (varstring), varstring);
830 fprintf_filtered (stream, "<null type?>");
835 type = ada_check_typedef (type);
837 if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
838 fprintf_filtered (stream, "%.*s: ",
839 ada_name_prefix_len (varstring), varstring);
841 if (type_name != NULL && show <= 0 && !ada_is_aligner_type (type))
843 fprintf_filtered (stream, "%.*s",
844 ada_name_prefix_len (type_name), type_name);
848 if (ada_is_aligner_type (type))
849 ada_print_type (ada_aligned_type (type), "", stream, show, level, flags);
850 else if (ada_is_constrained_packed_array_type (type)
851 && TYPE_CODE (type) != TYPE_CODE_PTR)
852 print_array_type (type, stream, show, level, flags);
854 switch (TYPE_CODE (type))
857 fprintf_filtered (stream, "<");
858 c_print_type (type, "", stream, show, level, flags);
859 fprintf_filtered (stream, ">");
862 case TYPE_CODE_TYPEDEF:
863 fprintf_filtered (stream, "access ");
864 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
868 fprintf_filtered (stream, "<ref> ");
869 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
872 case TYPE_CODE_ARRAY:
873 print_array_type (type, stream, show, level, flags);
876 fprintf_filtered (stream, "(false, true)");
879 if (ada_is_fixed_point_type (type))
880 print_fixed_point_type (type, stream);
883 const char *name = ada_type_name (type);
885 if (!ada_is_range_type_name (name))
886 fprintf_filtered (stream, _("<%d-byte integer>"),
890 fprintf_filtered (stream, "range ");
891 print_range_type (type, stream, 1 /* bounds_prefered_p */);
895 case TYPE_CODE_RANGE:
896 if (ada_is_fixed_point_type (type))
897 print_fixed_point_type (type, stream);
898 else if (ada_is_modular_type (type))
899 fprintf_filtered (stream, "mod %s",
900 int_string (ada_modulus (type), 10, 0, 0, 1));
903 fprintf_filtered (stream, "range ");
904 print_range (type, stream, 1 /* bounds_prefered_p */);
908 fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
912 fprintf_filtered (stream, "(...)");
914 print_enum_type (type, stream);
916 case TYPE_CODE_STRUCT:
917 if (ada_is_array_descriptor_type (type))
918 print_array_type (type, stream, show, level, flags);
919 else if (ada_is_bogus_array_descriptor (type))
920 fprintf_filtered (stream,
921 _("array (?) of ? (<mal-formed descriptor>)"));
923 print_record_type (type, stream, show, level, flags);
925 case TYPE_CODE_UNION:
926 print_unchecked_union_type (type, stream, show, level, flags);
929 print_func_type (type, stream, varstring, flags);
934 /* Implement the la_print_typedef language method for Ada. */
937 ada_print_typedef (struct type *type, struct symbol *new_symbol,
938 struct ui_file *stream)
940 type = ada_check_typedef (type);
941 ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
942 fprintf_filtered (stream, "\n");