if (name != NULL && name[0] != '\0')
{
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
fputs_styled (name, function_name_style.style (), stream);
}
{
if (i > 0)
{
- fputs_filtered ("; ", stream);
+ gdb_puts ("; ", stream);
stream->wrap_here (4);
}
fprintf_filtered (stream, "a%d: ", i + 1);
/* Don't try to modify a result representing an error. */
if (s[0] == '<')
{
- fputs_filtered (s.c_str (), stream);
+ gdb_puts (s.c_str (), stream);
return;
}
void
ada_printchar (int c, struct type *type, struct ui_file *stream)
{
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
ada_emit_char (c, type, stream, '\'', TYPE_LENGTH (type));
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
}
/* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
if (length == 0)
{
- fputs_filtered ("\"\"", stream);
+ gdb_puts ("\"\"", stream);
return;
}
if (need_comma)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
need_comma = 0;
}
{
if (in_quotes)
{
- fputs_filtered ("\", ", stream);
+ gdb_puts ("\", ", stream);
in_quotes = 0;
}
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
ada_emit_char (char_at (string, i, type_len, byte_order),
elttype, stream, '\'', type_len);
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
fprintf_filtered (stream, _(" %p[<repeats %u times>%p]"),
metadata_style.style ().ptr (), reps, nullptr);
i = rep1 - 1;
{
if (!in_quotes)
{
- fputs_filtered ("\"", stream);
+ gdb_puts ("\"", stream);
in_quotes = 1;
}
ada_emit_char (char_at (string, i, type_len, byte_order),
/* Terminate the quotes if necessary. */
if (in_quotes)
- fputs_filtered ("\"", stream);
+ gdb_puts ("\"", stream);
if (force_ellipses || i < length)
- fputs_filtered ("...", stream);
+ gdb_puts ("...", stream);
}
void
ada_name_prefix_len (type->field (i).name ()),
type->field (i).name ());
annotate_field_name_end ();
- fputs_filtered (" => ", stream);
+ gdb_puts (" => ", stream);
annotate_field_value ();
if (TYPE_FIELD_PACKED (type, i))
&& TYPE_TARGET_TYPE (value_type (val))->code () == TYPE_CODE_INT
&& TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (val))) == 0)
{
- fputs_filtered ("null", stream);
+ gdb_puts ("null", stream);
return;
}
fprintf_filtered (stream, "(");
type_print (type, "", stream, -1);
fprintf_filtered (stream, ") ");
- fputs_filtered (paddress (gdbarch, addr), stream);
+ gdb_puts (paddress (gdbarch, addr), stream);
}
else
{
{
LONGEST c;
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
c = unpack_long (type, valaddr);
ada_printchar (c, type, stream);
}
deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
if (deref_val_int == 0)
{
- fputs_filtered ("(null)", stream);
+ gdb_puts ("(null)", stream);
return;
}
print_fpu_flags (struct ui_file *file, int flags)
{
if (flags & (1 << 0))
- fputs_filtered ("IVO ", file);
+ gdb_puts ("IVO ", file);
if (flags & (1 << 1))
- fputs_filtered ("DVZ ", file);
+ gdb_puts ("DVZ ", file);
if (flags & (1 << 2))
- fputs_filtered ("OFL ", file);
+ gdb_puts ("OFL ", file);
if (flags & (1 << 3))
- fputs_filtered ("UFL ", file);
+ gdb_puts ("UFL ", file);
if (flags & (1 << 4))
- fputs_filtered ("INX ", file);
+ gdb_puts ("INX ", file);
fputc_filtered ('\n', file);
}
else
fprintf_filtered (file, _("Software FPU type %d\n"), type);
/* i18n: [floating point unit] mask */
- fputs_filtered (_("mask: "), file);
+ gdb_puts (_("mask: "), file);
print_fpu_flags (file, status >> 16);
/* i18n: [floating point unit] flags */
- fputs_filtered (_("flags: "), file);
+ gdb_puts (_("flags: "), file);
print_fpu_flags (file, status);
}
fprintf_filtered (f, "%3d %s", i, aop_map[op].name);
if (aop_map[op].op_size > 0)
{
- fputs_filtered (" ", f);
+ gdb_puts (" ", f);
print_longest (f, 'd', 0,
read_const (x, i + 1, aop_map[op].op_size));
case C_STRING:
break;
case C_WIDE_STRING:
- fputs_filtered ("L", stream);
+ gdb_puts ("L", stream);
break;
case C_STRING_16:
- fputs_filtered ("u", stream);
+ gdb_puts ("u", stream);
break;
case C_STRING_32:
- fputs_filtered ("U", stream);
+ gdb_puts ("U", stream);
break;
}
find_typedef_for_canonicalize,
(void *) flags);
- fputs_filtered (s != nullptr ? s.get () : name, stream);
+ gdb_puts (s != nullptr ? s.get () : name, stream);
}
\f
if (local_name != NULL)
{
c_type_print_modifier (type, stream, 0, 1, language);
- fputs_filtered (local_name, stream);
+ gdb_puts (local_name, stream);
if (varstring != NULL && *varstring != '\0')
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
else
{
|| code == TYPE_CODE_MEMBERPTR
|| code == TYPE_CODE_METHODPTR
|| TYPE_IS_REFERENCE (type))))
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,
language, flags, podata);
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
stream->wrap_here (8);
- fputs_filtered (i == 0 ? ": " : ", ", stream);
+ gdb_puts (i == 0 ? ": " : ", ", stream);
fprintf_filtered (stream, "%s%s ",
BASETYPE_VIA_PUBLIC (type, i)
? "public" : (TYPE_FIELD_PROTECTED (type, i)
}
if (i > 0)
{
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
}
language_cplus, DMGL_ANSI);
fprintf_symbol_filtered (stream, varstring,
language_cplus, DMGL_ANSI);
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
/* Skip the class variable. We keep this here to accommodate older
compilers and debug formats which may not support artificial
}
else
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
stream->wrap_here (9);
fprintf_filtered (stream, "%s = ", sym->linkage_name ());
}
}
if (!first)
- fputs_filtered (_("] "), stream);
+ gdb_puts (_("] "), stream);
}
/* Use 'print_spaces_filtered', but take into consideration the
here. */
print_name_maybe_canonical (type->name (), flags, stream);
if (show > 0)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
if (show < 0)
(TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
"", stream, -1, 0, language, &local_flags, podata);
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
if (TYPE_FN_FIELD_STUB (f, j))
{
int length = p - demangled_no_class;
std::string demangled_no_static (demangled_no_class,
length);
- fputs_filtered (demangled_no_static.c_str (), stream);
+ gdb_puts (demangled_no_static.c_str (), stream);
}
else
- fputs_filtered (demangled_no_class, stream);
+ gdb_puts (demangled_no_class, stream);
}
fprintf_filtered (stream, ";\n");
{
print_name_maybe_canonical (type->name (), flags, stream);
if (show > 0)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
stream->wrap_here (4);
print_name_maybe_canonical (type->name (), flags, stream);
if (show > 0)
{
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
fprintf_filtered (stream, "{\n");
if (type->num_fields () == 0)
{
break;
case TYPE_CODE_NAMESPACE:
- fputs_filtered ("namespace ", stream);
- fputs_filtered (type->name (), stream);
+ gdb_puts ("namespace ", stream);
+ gdb_puts (type->name (), stream);
break;
default:
demangle);
else if (options->addressprint)
{
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_puts (paddress (gdbarch, address), stream);
want_space = 1;
}
&& address != 0)
{
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
val_print_string (unresolved_elttype, NULL, address, -1, stream, options);
}
else if (cp_is_vtbl_member (type))
&& (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol)))
{
if (want_space)
- fputs_filtered (" ", stream);
- fputs_filtered (" <", stream);
- fputs_filtered (msymbol.minsym->print_name (), stream);
- fputs_filtered (">", stream);
+ gdb_puts (" ", stream);
+ gdb_puts (" <", stream);
+ gdb_puts (msymbol.minsym->print_name (), stream);
+ gdb_puts (">", stream);
want_space = 1;
}
struct type *wtype;
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
if (msymbol.minsym != NULL)
{
const gdb_byte *valaddr = value_contents_for_printing (val).data ();
if (c_textual_element_type (type, options->format))
{
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
current_language->printchar (unpack_long (type, valaddr), type,
stream);
}
return;
if (test_flags (unfiltered_output))
- fputs_unfiltered (string, m_streams.back ());
+ gdb_puts (string, m_streams.back ());
else
- fputs_filtered (string, m_streams.back ());
+ gdb_puts (string, m_streams.back ());
}
void
struct ui_file *stream)
{
gdb_assert (c.is_alias ());
- fputs_filtered (" alias ", stream);
+ gdb_puts (" alias ", stream);
fput_command_name_styled (c, stream);
fprintf_filtered (stream, " = ");
fput_command_name_styled (*c.alias_target, stream);
if (!print_alias (alias))
continue;
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
stream->wrap_here (3);
fput_command_name_styled (alias, stream);
}
if (print_something)
- fputs_filtered (postfix, stream);
+ gdb_puts (postfix, stream);
}
/* If VERBOSE, print the full help for command C and highlight the
this documentation from the previous command help, in the likely
case that apropos finds several commands. */
if (verbose)
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
fput_command_names_styled (c, true,
verbose ? "" : " -- ", stream);
if (verbose)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
fput_aliases_definition_styled (c, stream);
fputs_highlighted (c.doc, highlight, stream);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
}
else
{
print_doc_line (stream, c.doc, false);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
fput_aliases_definition_styled (c, stream);
}
}
the false indicates to not output the (single) command name. */
fput_command_names_styled (*c, false, "\n", stream);
fput_aliases_definition_styled (*c, stream);
- fputs_filtered (c->doc, stream);
- fputs_filtered ("\n", stream);
+ gdb_puts (c->doc, stream);
+ gdb_puts ("\n", stream);
if (!c->is_prefix () && !c->is_command_class_help ())
return;
fprintf_filtered (stream, "\nType \"help%s\" followed by %scommand name ",
cmdtype1, cmdtype2);
stream->wrap_here (0);
- fputs_filtered ("for ", stream);
+ gdb_puts ("for ", stream);
stream->wrap_here (0);
- fputs_filtered ("full ", stream);
+ gdb_puts ("full ", stream);
stream->wrap_here (0);
- fputs_filtered ("documentation.\n", stream);
- fputs_filtered ("Type \"apropos word\" to search "
- "for commands related to \"word\".\n", stream);
- fputs_filtered ("Type \"apropos -v word\" for full documentation", stream);
+ gdb_puts ("documentation.\n", stream);
+ gdb_puts ("Type \"apropos word\" to search "
+ "for commands related to \"word\".\n", stream);
+ gdb_puts ("Type \"apropos -v word\" for full documentation", stream);
stream->wrap_here (0);
- fputs_filtered (" of commands related to \"word\".\n", stream);
- fputs_filtered ("Command name abbreviations are allowed if unambiguous.\n",
- stream);
+ gdb_puts (" of commands related to \"word\".\n", stream);
+ gdb_puts ("Command name abbreviations are allowed if unambiguous.\n",
+ stream);
}
static void
}
else
line_buffer[p - str] = '\0';
- fputs_filtered (line_buffer, stream);
+ gdb_puts (line_buffer, stream);
}
/* Print one-line help for command C.
{
fput_command_names_styled (c, true, " -- ", stream);
print_doc_line (stream, c.doc, false);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
if (!c.default_args.empty ())
fput_alias_definition_styled (c, stream);
fput_aliases_definition_styled (c, stream);
(unsigned long) sec_start + sec_offset
+ load_offset + sec_load_count));
else
- puts_filtered ("\n");
+ gdb_puts ("\n");
/* Write the data. */
ret = target_write_memory (sec_start + sec_offset + load_offset,
va_start (args, fmt);
gdb_vprintf (fmt, args);
va_end (args);
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
/* Helper for execute_control_command. */
if (cmdlines)
{
print_command_lines (current_uiout, cmdlines, 1);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
}
}
const char *value)
{
cli_style_option *cso = (cli_style_option *) cmd->context ();
- fputs_filtered (_("The "), file);
+ gdb_puts (_("The "), file);
fprintf_styled (file, cso->style (), _("\"%s\" style"), cso->name ());
fprintf_filtered (file, _(" %s is: %s\n"), what, value);
}
{
int i;
- fputs_filtered ("(", file);
+ gdb_puts ("(", file);
for (i = 0; i < macro->argc; i++)
{
- fputs_filtered (macro->argv[i], file);
+ gdb_puts (macro->argv[i], file);
if (i + 1 < macro->argc)
- fputs_filtered (", ", file);
+ gdb_puts (", ", file);
}
- fputs_filtered (")", file);
+ gdb_puts (")", file);
}
fprintf_filtered (file, " %s\n#endif\n", macro->replacement);
int i;
int seen = 0;
- fputs_unfiltered ("struct " COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG " {\n",
- stream);
+ gdb_puts ("struct " COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG " {\n",
+ stream);
if (!registers_used.empty ())
for (i = 0; i < gdbarch_num_regs (gdbarch); ++i)
register types (typically flags or vectors), emit a
maximally-aligned array of the correct size. */
- fputs_unfiltered (" ", stream);
+ gdb_puts (" ", stream);
switch (regtype->code ())
{
case TYPE_CODE_PTR:
if (mode != NULL)
{
if (regtype->is_unsigned ())
- fputs_unfiltered ("unsigned ", stream);
+ gdb_puts ("unsigned ", stream);
fprintf_unfiltered (stream,
"int %s"
" __attribute__ ((__mode__(__%s__)))",
regname.c_str (),
pulongest (TYPE_LENGTH (regtype)));
}
- fputs_unfiltered (";\n", stream);
+ gdb_puts (";\n", stream);
}
}
if (!seen)
- fputs_unfiltered (" char " COMPILE_I_SIMPLE_REGISTER_DUMMY ";\n",
- stream);
+ gdb_puts (" char " COMPILE_I_SIMPLE_REGISTER_DUMMY ";\n",
+ stream);
- fputs_unfiltered ("};\n\n", stream);
+ gdb_puts ("};\n\n", stream);
}
/* C-language policy to emit a push user expression pragma into BUF. */
{
void push_user_expression (struct ui_file *buf)
{
- fputs_unfiltered ("#pragma GCC user_expression\n", buf);
+ gdb_puts ("#pragma GCC user_expression\n", buf);
}
};
switch (type)
{
case COMPILE_I_SIMPLE_SCOPE:
- fputs_unfiltered ("void "
- GCC_FE_WRAPPER_FUNCTION
- " (struct "
- COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
- " *"
- COMPILE_I_SIMPLE_REGISTER_ARG_NAME
- ") {\n",
- buf);
+ gdb_puts ("void "
+ GCC_FE_WRAPPER_FUNCTION
+ " (struct "
+ COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
+ " *"
+ COMPILE_I_SIMPLE_REGISTER_ARG_NAME
+ ") {\n",
+ buf);
break;
case COMPILE_I_PRINT_ADDRESS_SCOPE:
case COMPILE_I_PRINT_VALUE_SCOPE:
/* <string.h> is needed for a memcpy call below. */
- fputs_unfiltered ("#include <string.h>\n"
- "void "
- GCC_FE_WRAPPER_FUNCTION
- " (struct "
- COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
- " *"
- COMPILE_I_SIMPLE_REGISTER_ARG_NAME
- ", "
- COMPILE_I_PRINT_OUT_ARG_TYPE
- " "
- COMPILE_I_PRINT_OUT_ARG
- ") {\n",
- buf);
+ gdb_puts ("#include <string.h>\n"
+ "void "
+ GCC_FE_WRAPPER_FUNCTION
+ " (struct "
+ COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
+ " *"
+ COMPILE_I_SIMPLE_REGISTER_ARG_NAME
+ ", "
+ COMPILE_I_PRINT_OUT_ARG_TYPE
+ " "
+ COMPILE_I_PRINT_OUT_ARG
+ ") {\n",
+ buf);
break;
case COMPILE_I_RAW_SCOPE:
case COMPILE_I_SIMPLE_SCOPE:
case COMPILE_I_PRINT_ADDRESS_SCOPE:
case COMPILE_I_PRINT_VALUE_SCOPE:
- fputs_unfiltered ("}\n", buf);
+ gdb_puts ("}\n", buf);
break;
case COMPILE_I_RAW_SCOPE:
break;
default:
- fputs_unfiltered (input, buf);
+ gdb_puts (input, buf);
break;
}
- fputs_unfiltered ("\n", buf);
+ gdb_puts ("\n", buf);
}
};
{
void push_user_expression (struct ui_file *buf)
{
- fputs_unfiltered ("#pragma GCC push_user_expression\n", buf);
+ gdb_puts ("#pragma GCC push_user_expression\n", buf);
}
};
{
void pop_user_expression (struct ui_file *buf)
{
- fputs_unfiltered ("#pragma GCC pop_user_expression\n", buf);
+ gdb_puts ("#pragma GCC pop_user_expression\n", buf);
}
};
switch (type)
{
case COMPILE_I_SIMPLE_SCOPE:
- fputs_unfiltered ("void "
- GCC_FE_WRAPPER_FUNCTION
- " (struct "
- COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
- " *"
- COMPILE_I_SIMPLE_REGISTER_ARG_NAME
- ") {\n",
- buf);
+ gdb_puts ("void "
+ GCC_FE_WRAPPER_FUNCTION
+ " (struct "
+ COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
+ " *"
+ COMPILE_I_SIMPLE_REGISTER_ARG_NAME
+ ") {\n",
+ buf);
break;
case COMPILE_I_PRINT_ADDRESS_SCOPE:
case COMPILE_I_PRINT_VALUE_SCOPE:
- fputs_unfiltered (
- "#include <cstring>\n"
- "#include <bits/move.h>\n"
- "void "
- GCC_FE_WRAPPER_FUNCTION
- " (struct "
- COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
- " *"
- COMPILE_I_SIMPLE_REGISTER_ARG_NAME
- ", "
- COMPILE_I_PRINT_OUT_ARG_TYPE
- " "
- COMPILE_I_PRINT_OUT_ARG
- ") {\n",
- buf);
+ gdb_puts (
+ "#include <cstring>\n"
+ "#include <bits/move.h>\n"
+ "void "
+ GCC_FE_WRAPPER_FUNCTION
+ " (struct "
+ COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
+ " *"
+ COMPILE_I_SIMPLE_REGISTER_ARG_NAME
+ ", "
+ COMPILE_I_PRINT_OUT_ARG_TYPE
+ " "
+ COMPILE_I_PRINT_OUT_ARG
+ ") {\n",
+ buf);
break;
case COMPILE_I_RAW_SCOPE:
break;
default:
- fputs_unfiltered (input, buf);
+ gdb_puts (input, buf);
break;
}
- fputs_unfiltered ("\n", buf);
+ gdb_puts ("\n", buf);
}
};
compile_cplus_debug_output_1 (const char *arg)
{
if (arg == nullptr)
- fputs_unfiltered ("NULL", gdb_stdlog);
+ gdb_puts ("NULL", gdb_stdlog);
else
- fputs_unfiltered (arg, gdb_stdlog);
+ gdb_puts (arg, gdb_stdlog);
}
static void
#define OUTPUT_DEBUG_RESULT(R) \
if (debug_compile_cplus_types) \
{ \
- fputs_unfiltered (": ", gdb_stdlog); \
+ gdb_puts (": ", gdb_stdlog); \
compile_cplus_debug_output (R); \
fputc_unfiltered ('\n', gdb_stdlog); \
} \
static void
print_callback (void *ignore, const char *message)
{
- fputs_filtered (message, gdb_stderr);
+ gdb_puts (message, gdb_stderr);
}
/* Process the compilation request. On success it returns the object
(*deprecated_warning_hook) (fmt, args);
else
{
- fputs_filtered (_("During symbol reading: "), gdb_stderr);
+ gdb_puts (_("During symbol reading: "), gdb_stderr);
gdb_vprintf (gdb_stderr, fmt, args);
- fputs_filtered ("\n", gdb_stderr);
+ gdb_puts ("\n", gdb_stderr);
}
va_end (args);
if (fields_seen)
{
- fputs_filtered (",", stream);
+ gdb_puts (",", stream);
if (!options->prettyformat)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
else if (n_baseclasses > 0)
{
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
- fputs_filtered ("members of ", stream);
- fputs_filtered (type->name (), stream);
- fputs_filtered (":", stream);
+ gdb_puts ("members of ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (":", stream);
}
}
fields_seen = 1;
if (field_is_static (&type->field (i)))
{
- fputs_filtered ("static ", stream);
+ gdb_puts ("static ", stream);
fprintf_symbol_filtered (stream,
type->field (i).name (),
current_language->la_language,
/* Do not print leading '=' in case of anonymous
unions. */
if (strcmp (type->field (i).name (), ""))
- fputs_filtered (" = ", stream);
+ gdb_puts (" = ", stream);
else
{
/* If this is an anonymous field then we want to consider it
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
- fputs_filtered ("<", stream);
+ gdb_puts ("<", stream);
/* Not sure what the best notation is in the case where there is
no baseclass name. */
- fputs_filtered (basename ? basename : "", stream);
- fputs_filtered ("> = ", stream);
+ gdb_puts (basename ? basename : "", stream);
+ gdb_puts ("> = ", stream);
if (skip < 0)
val_print_unavailable (stream);
0);
}
}
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
flush_it:
;
{
const char *name;
- fputs_filtered (prefix, stream);
+ gdb_puts (prefix, stream);
name = self_type->name ();
if (name)
- fputs_filtered (name, stream);
+ gdb_puts (name, stream);
else
c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
fprintf_filtered (stream, "::");
if (valid_options_and_args == NULL)
{
- fputs_filtered (_("There are no disassembler options available "
- "for this architecture.\n"),
- file);
+ gdb_puts (_("There are no disassembler options available "
+ "for this architecture.\n"),
+ file);
return;
}
fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
for (idx = 0; idx < (*resultp)->callers; idx++)
tailcall_dump (gdbarch, (*resultp)->call_site[idx]);
- fputs_unfiltered (" |", gdb_stdlog);
+ gdb_puts (" |", gdb_stdlog);
for (idx = 0; idx < (*resultp)->callees; idx++)
tailcall_dump (gdbarch,
(*resultp)->call_site[(*resultp)->length
case DW_FORM_addrx:
case DW_FORM_GNU_addr_index:
fprintf_unfiltered (f, "address: ");
- fputs_filtered (hex_string (die->attrs[i].as_address ()), f);
+ gdb_puts (hex_string (die->attrs[i].as_address ()), f);
break;
case DW_FORM_block2:
case DW_FORM_block4:
break;
case DW_FORM_ref_addr:
fprintf_unfiltered (f, "ref address: ");
- fputs_filtered (hex_string (die->attrs[i].as_unsigned ()), f);
+ gdb_puts (hex_string (die->attrs[i].as_unsigned ()), f);
break;
case DW_FORM_GNU_ref_alt:
fprintf_unfiltered (f, "alt ref address: ");
- fputs_filtered (hex_string (die->attrs[i].as_unsigned ()), f);
+ gdb_puts (hex_string (die->attrs[i].as_unsigned ()), f);
break;
case DW_FORM_ref1:
case DW_FORM_ref2:
catch (const gdb_exception &exception)
{
- fputs_filtered ("Could not kill the program being debugged",
- gdb_stderr);
+ gdb_puts ("Could not kill the program being debugged",
+ gdb_stderr);
exception_print (gdb_stderr, exception);
}
{
end = strchr (start, '\n');
if (end == NULL)
- fputs_filtered (start, file);
+ gdb_puts (start, file);
else
{
end++;
print_section_info (¤t_program_space->target_sections (),
current_program_space->exec_bfd ());
else
- puts_filtered (_("\t<no file loaded>\n"));
+ gdb_puts (_("\t<no file loaded>\n"));
}
static void
{
fprintf_filtered (stream, _("%*sType flags: "), depth, "");
if (flags & TYPE_INSTANCE_FLAG_CONST)
- fputs_filtered ("const ", stream);
+ gdb_puts ("const ", stream);
if (flags & TYPE_INSTANCE_FLAG_VOLATILE)
- fputs_filtered ("volatile", stream);
+ gdb_puts ("volatile", stream);
fprintf_filtered (stream, "\n");
}
switch (flags & ~C_CHAR)
{
case C_WIDE_STRING:
- fputs_filtered (_("wide "), stream);
+ gdb_puts (_("wide "), stream);
break;
case C_STRING_16:
- fputs_filtered (_("u16 "), stream);
+ gdb_puts (_("u16 "), stream);
break;
case C_STRING_32:
- fputs_filtered (_("u32 "), stream);
+ gdb_puts (_("u32 "), stream);
break;
default:
- fputs_filtered (_("ordinary "), stream);
+ gdb_puts (_("ordinary "), stream);
break;
}
if ((flags & C_CHAR) != 0)
- fputs_filtered (_("char"), stream);
+ gdb_puts (_("char"), stream);
else
- fputs_filtered (_("string"), stream);
- fputs_filtered ("\n", stream);
+ gdb_puts (_("string"), stream);
+ gdb_puts ("\n", stream);
}
void
{
fprintf_filtered (stream, _("%*sRange:"), depth, "");
if ((flags & RANGE_LOW_BOUND_DEFAULT) != 0)
- fputs_filtered (_("low-default "), stream);
+ gdb_puts (_("low-default "), stream);
if ((flags & RANGE_HIGH_BOUND_DEFAULT) != 0)
- fputs_filtered (_("high-default "), stream);
+ gdb_puts (_("high-default "), stream);
if ((flags & RANGE_HIGH_BOUND_EXCLUSIVE) != 0)
- fputs_filtered (_("high-exclusive "), stream);
+ gdb_puts (_("high-exclusive "), stream);
if ((flags & RANGE_HAS_STRIDE) != 0)
- fputs_filtered (_("has-stride"), stream);
+ gdb_puts (_("has-stride"), stream);
fprintf_filtered (stream, "\n");
}
void printchar (int ch, struct type *chtype,
struct ui_file *stream) const override
{
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
emitchar (ch, chtype, stream, '\'');
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
}
/* See language.h. */
const char *type_encoding = get_encoding (elttype);
if (TYPE_LENGTH (elttype) == 4)
- fputs_filtered ("4_", stream);
+ gdb_puts ("4_", stream);
if (!encoding || !*encoding)
encoding = type_encoding;
== TYPE_CODE_METHOD)
|| (TYPE_TARGET_TYPE (type)->code ()
== TYPE_CODE_ARRAY))))))
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
f_type_print_varspec_prefix (type, stream, show, 0);
if (varstring != NULL)
{
int demangled_args;
- fputs_filtered (varstring, stream);
+ gdb_puts (varstring, stream);
/* For demangled function names, we have the arglist as part of the name,
so don't print an additional pair of ()'s. */
{
LONGEST upper_bound = f77_get_upperbound (type);
- fputs_filtered (plongest (upper_bound), stream);
+ gdb_puts (plongest (upper_bound), stream);
}
}
{
if (i > 0)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
stream->wrap_here (4);
}
print_type (type->field (i).type (), "", stream, -1, 0, 0);
fprintf_filtered (stream, "%*sType, C_Union :: ", level, "");
else
fprintf_filtered (stream, "%*sType ", level, "");
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
/* According to the definition,
we only print structure elements in case show > 0. */
if (show > 0)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
for (index = 0; index < type->num_fields (); index++)
{
f_type_print_base (type->field (index).type (), stream,
show - 1, level + 4);
- fputs_filtered (" :: ", stream);
+ gdb_puts (" :: ", stream);
fputs_styled (type->field (index).name (),
variable_name_style.style (), stream);
f_type_print_varspec_suffix (type->field (index).type (),
stream, show - 1, 0, 0, 0, false);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
}
fprintf_filtered (stream, "%*sEnd Type ", level, "");
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
}
break;
{
bool cont = should_continue && (m_elts < m_options->print_max);
if (!cont && should_continue)
- fputs_filtered ("...", m_stream);
+ gdb_puts ("...", m_stream);
return cont;
}
m_stats[dim_indx].nelts = nelts;
}
- fputs_filtered ("(", m_stream);
+ gdb_puts ("(", m_stream);
}
/* Called when we finish processing a batch of items within a dimension
separators between elements, and dimensions of the array. */
void finish_dimension (bool inner_p, bool last_p)
{
- fputs_filtered (")", m_stream);
+ gdb_puts (")", m_stream);
if (!last_p)
- fputs_filtered (" ", m_stream);
+ gdb_puts (" ", m_stream);
m_dimension--;
}
nullptr);
annotate_elt_rep_end ();
if (!repeated)
- fputs_filtered (" ", m_stream);
+ gdb_puts (" ", m_stream);
m_elts += nrepeats * m_stats[dim_indx + 1].nelts;
}
else
nrepeats++;
}
else if (last_p)
- fputs_filtered ("...", m_stream);
+ gdb_puts ("...", m_stream);
}
}
common_val_print (e_val, m_stream, m_recurse, m_options,
current_language);
if (i > 1)
- fputs_filtered (", ", m_stream);
+ gdb_puts (", ", m_stream);
}
}
printed = true;
= value_from_component (m_val, elt_type, elt_off);
if (printed)
- fputs_filtered (", ", m_stream);
+ gdb_puts (", ", m_stream);
maybe_print_array_index (m_stats[dim_indx].index_type, index,
m_stream, m_options);
common_val_print (e_val, m_stream, m_recurse, m_options,
current_language);
}
if (!last_p)
- fputs_filtered (", ", m_stream);
+ gdb_puts (", ", m_stream);
}
m_elt_type_prev = elt_type;
stream, demangle);
else if (options->addressprint && options->format != 's')
{
- fputs_filtered (paddress (gdbarch, addr), stream);
+ gdb_puts (paddress (gdbarch, addr), stream);
want_space = 1;
}
&& addr != 0)
{
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
stream, options);
}
field = value_field (val, index);
if (printed_field > 0)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
if (field_name != NULL)
{
fputs_styled (field_name, variable_name_style.style (),
stream);
- fputs_filtered (" = ", stream);
+ gdb_puts (" = ", stream);
}
common_val_print (field, stream, recurse + 1,
represented. Different compilers use different non zero
values to represent logical true. */
if (longval == 0)
- fputs_filtered (f_decorations.false_name, stream);
+ gdb_puts (f_decorations.false_name, stream);
else
- fputs_filtered (f_decorations.true_name, stream);
+ gdb_puts (f_decorations.true_name, stream);
}
break;
{
if ((bitno % 8) == 0)
{
- puts_filtered (" ");
+ gdb_puts (" ");
}
if (B_TST (bits, bitno))
printf_filtered (("1"));
print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
TYPE_N_BASECLASSES (type));
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
if (type->num_fields () > 0)
{
host_address_to_string (TYPE_FIELD_PRIVATE_BITS (type)));
print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
type->num_fields ());
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
{
host_address_to_string (TYPE_FIELD_PROTECTED_BITS (type)));
print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
type->num_fields ());
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
}
if (TYPE_NFN_FIELDS (type) > 0)
printf_filtered ("(UNKNOWN TYPE CODE)");
break;
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
printf_filtered ("%*slength %s\n", spaces, "",
pulongest (TYPE_LENGTH (type)));
if (type->is_objfile_owned ())
(unsigned) type->instance_flags ());
if (TYPE_CONST (type))
{
- puts_filtered (" TYPE_CONST");
+ gdb_puts (" TYPE_CONST");
}
if (TYPE_VOLATILE (type))
{
- puts_filtered (" TYPE_VOLATILE");
+ gdb_puts (" TYPE_VOLATILE");
}
if (TYPE_CODE_SPACE (type))
{
- puts_filtered (" TYPE_CODE_SPACE");
+ gdb_puts (" TYPE_CODE_SPACE");
}
if (TYPE_DATA_SPACE (type))
{
- puts_filtered (" TYPE_DATA_SPACE");
+ gdb_puts (" TYPE_DATA_SPACE");
}
if (TYPE_ADDRESS_CLASS_1 (type))
{
- puts_filtered (" TYPE_ADDRESS_CLASS_1");
+ gdb_puts (" TYPE_ADDRESS_CLASS_1");
}
if (TYPE_ADDRESS_CLASS_2 (type))
{
- puts_filtered (" TYPE_ADDRESS_CLASS_2");
+ gdb_puts (" TYPE_ADDRESS_CLASS_2");
}
if (TYPE_RESTRICT (type))
{
- puts_filtered (" TYPE_RESTRICT");
+ gdb_puts (" TYPE_RESTRICT");
}
if (TYPE_ATOMIC (type))
{
- puts_filtered (" TYPE_ATOMIC");
+ gdb_puts (" TYPE_ATOMIC");
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
printf_filtered ("%*sflags", spaces, "");
if (type->is_unsigned ())
{
- puts_filtered (" TYPE_UNSIGNED");
+ gdb_puts (" TYPE_UNSIGNED");
}
if (type->has_no_signedness ())
{
- puts_filtered (" TYPE_NOSIGN");
+ gdb_puts (" TYPE_NOSIGN");
}
if (type->endianity_is_not_default ())
{
- puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT");
+ gdb_puts (" TYPE_ENDIANITY_NOT_DEFAULT");
}
if (type->is_stub ())
{
- puts_filtered (" TYPE_STUB");
+ gdb_puts (" TYPE_STUB");
}
if (type->target_is_stub ())
{
- puts_filtered (" TYPE_TARGET_STUB");
+ gdb_puts (" TYPE_TARGET_STUB");
}
if (type->is_prototyped ())
{
- puts_filtered (" TYPE_PROTOTYPED");
+ gdb_puts (" TYPE_PROTOTYPED");
}
if (type->has_varargs ())
{
- puts_filtered (" TYPE_VARARGS");
+ gdb_puts (" TYPE_VARARGS");
}
/* This is used for things like AltiVec registers on ppc. Gcc emits
an attribute for the array type, which tells whether or not we
have a vector, instead of a regular array. */
if (type->is_vector ())
{
- puts_filtered (" TYPE_VECTOR");
+ gdb_puts (" TYPE_VECTOR");
}
if (type->is_fixed_instance ())
{
- puts_filtered (" TYPE_FIXED_INSTANCE");
+ gdb_puts (" TYPE_FIXED_INSTANCE");
}
if (type->stub_is_supported ())
{
- puts_filtered (" TYPE_STUB_SUPPORTED");
+ gdb_puts (" TYPE_STUB_SUPPORTED");
}
if (TYPE_NOTTEXT (type))
{
- puts_filtered (" TYPE_NOTTEXT");
+ gdb_puts (" TYPE_NOTTEXT");
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
printf_filtered ("%*snfields %d ", spaces, "", type->num_fields ());
if (TYPE_ASSOCIATED_PROP (type) != nullptr
|| TYPE_ALLOCATED_PROP (type) != nullptr)
printf_filtered ("%*sfloatformat ", spaces, "");
if (TYPE_FLOATFORMAT (type) == NULL
|| TYPE_FLOATFORMAT (type)->name == NULL)
- puts_filtered ("(null)");
+ gdb_puts ("(null)");
else
- puts_filtered (TYPE_FLOATFORMAT (type)->name);
- puts_filtered ("\n");
+ gdb_puts (TYPE_FLOATFORMAT (type)->name);
+ gdb_puts ("\n");
break;
case TYPE_SPECIFIC_FUNC:
case TYPE_SPECIFIC_FIXED_POINT:
printf_filtered ("%*sfixed_point_info ", spaces, "");
print_fixed_point_type_info (type, spaces);
- puts_filtered ("\n");
+ gdb_puts ("\n");
break;
case TYPE_SPECIFIC_INT:
fprintf_filtered (stream, "&virtual ");
if (demangled_name == NULL)
- fputs_filtered (physname, stream);
+ gdb_puts (physname, stream);
else
- fputs_filtered (demangled_name.get (), stream);
+ gdb_puts (demangled_name.get (), stream);
return;
}
}
else if (ptr_value != 0)
{
/* Found a non-virtual function: print out the type. */
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
- fputs_filtered (") ", stream);
+ gdb_puts (") ", stream);
}
/* We didn't find it; print the raw data. */
if (type->code () == TYPE_CODE_ARRAY
&& TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_CHAR)
{
- fputs_filtered ("string", stream);
+ gdb_puts ("string", stream);
return;
}
/* TODO(dje): Print address of struct or actual string? */
if (options->addressprint)
{
- fputs_filtered (paddress (gdbarch, addr), stream);
- fputs_filtered (" ", stream);
+ gdb_puts (paddress (gdbarch, addr), stream);
+ gdb_puts (" ", stream);
}
if (length < 0)
{
if (in_pages_p)
datum <<= 12;
- puts_filtered (header);
+ gdb_puts (header);
if (datum > 1024)
{
printf_filtered ("%lu KB", datum >> 10);
}
else
printf_filtered ("%lu Bytes", datum);
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
}
printf_filtered ("CPU Type.......................%s", u.machine);
if (cpuid_vendor[0])
printf_filtered (" (%s)", cpuid_vendor);
- puts_filtered ("\n");
+ gdb_puts ("\n");
/* CPUID with EAX = 1 returns processor signature and features. */
if (cpuid_max >= 1)
|| ((cpuid_edx & 1) == 0)
|| ((amd_p || hygon_p) && (cpuid_edx & (3 << 30)) != 0))
{
- puts_filtered ("CPU Features...................");
+ gdb_puts ("CPU Features...................");
/* We only list features which might be useful in the DPMI
environment. */
if ((cpuid_edx & 1) == 0)
- puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
+ gdb_puts ("No FPU "); /* It's unusual to not have an FPU. */
if ((cpuid_edx & (1 << 1)) != 0)
- puts_filtered ("VME ");
+ gdb_puts ("VME ");
if ((cpuid_edx & (1 << 2)) != 0)
- puts_filtered ("DE ");
+ gdb_puts ("DE ");
if ((cpuid_edx & (1 << 4)) != 0)
- puts_filtered ("TSC ");
+ gdb_puts ("TSC ");
if ((cpuid_edx & (1 << 23)) != 0)
- puts_filtered ("MMX ");
+ gdb_puts ("MMX ");
if ((cpuid_edx & (1 << 25)) != 0)
- puts_filtered ("SSE ");
+ gdb_puts ("SSE ");
if ((cpuid_edx & (1 << 26)) != 0)
- puts_filtered ("SSE2 ");
+ gdb_puts ("SSE2 ");
if (amd_p || hygon_p)
{
if ((cpuid_edx & (1 << 31)) != 0)
- puts_filtered ("3DNow! ");
+ gdb_puts ("3DNow! ");
if ((cpuid_edx & (1 << 30)) != 0)
- puts_filtered ("3DNow!Ext");
+ gdb_puts ("3DNow!Ext");
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
printf_filtered ("DOS Version....................%s %s.%s",
_os_flavor, u.release, u.version);
if (true_dos_version != advertized_dos_version)
printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
- puts_filtered ("\n");
+ gdb_puts ("\n");
if (!windows_major)
go32_get_windows_version ();
if (windows_major != 0xff)
else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
printf_filtered ("Windows Version................"
"Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
- puts_filtered ("\n");
+ gdb_puts ("\n");
/* On some versions of Windows, __dpmi_get_capabilities returns
zero, but the buffer is not filled with info, so we fill the
buffer with a known pattern and test for it afterwards. */
a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
(a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
__dpmi_get_free_memory_information (&mem_info);
print_mem (mem_info.total_number_of_physical_pages,
"DPMI Total Physical Memory.....", 1);
/* Get the descriptor from the table. */
if (idx == 0 && type == 0)
- puts_filtered ("0x000: null descriptor\n");
+ gdb_puts ("0x000: null descriptor\n");
else if (get_descriptor (base_addr, idx, &descr) != -1)
{
/* For each type of descriptor table, this has a bit set if the
descr.stype == 3 ? "" : "in");
break;
case 2:
- puts_filtered (" LDT");
+ gdb_puts (" LDT");
break;
case 4:
memcpy (&gate, &descr, sizeof gate);
printf_filtered ("Unknown type 0x%02x", descr.stype);
break;
}
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
else if (force)
{
type == 1
? idx : (idx * 8) | (type ? (cpl | 4) : 0));
if (!descr.present)
- puts_filtered ("Segment not present\n");
+ gdb_puts ("Segment not present\n");
else
printf_filtered ("Segment type 0x%02x is invalid in this table\n",
descr.stype);
__asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
ldt_idx = ldtr / 8;
if (ldt_idx == 0)
- puts_filtered ("There is no LDT.\n");
+ gdb_puts ("There is no LDT.\n");
/* LDT's entry in the GDT must have the type LDT, which is 2. */
else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
{
printf_filtered ("Base=0x%05lx000", entry >> 12);
if ((entry & 0x100) && !is_dir)
- puts_filtered (" Global");
+ gdb_puts (" Global");
if ((entry & 0x40) && !is_dir)
- puts_filtered (" Dirty");
+ gdb_puts (" Dirty");
printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
if (off)
printf_filtered (" +0x%x", off);
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
else if (force)
printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
pdbr = get_cr3 ();
if (!pdbr)
- puts_filtered ("Access to Page Directories is "
- "not supported on this system.\n");
+ gdb_puts ("Access to Page Directories is "
+ "not supported on this system.\n");
else if (pde_idx >= 0)
display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
else
"Page Directory entry 0x%lx:\n", n);
for (i = 0; i < 1024; i++)
display_ptable_entry (get_pte (pde, i), 0, 0, 0);
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
else if (force)
printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
pdbr = get_cr3 ();
if (!pdbr)
- puts_filtered ("Access to Page Tables is not supported on this system.\n");
+ gdb_puts ("Access to Page Tables is not supported on this system.\n");
else if (pde_idx >= 0)
display_page_table (pde_idx, 1);
else
pdbr = get_cr3 ();
if (!pdbr)
- puts_filtered ("Access to Page Tables is not supported on this system.\n");
+ gdb_puts ("Access to Page Tables is not supported on this system.\n");
else
{
int pde_idx = (addr >> 22) & 0x3ff;
for (i = 0; i < size; ++i)
{
if (s[i] == '\0')
- fputs_filtered ("\\000", stream);
+ gdb_puts ("\\000", stream);
else
fputc_filtered (s[i], stream);
}
for (i = 0; i < length; ++i)
{
if (string.get ()[i] == '\0')
- fputs_filtered ("\\000", stream);
+ gdb_puts ("\\000", stream);
else
fputc_filtered (string.get ()[i], stream);
}
if (i == 0)
{
if (!printed_nothing)
- fputs_filtered (" = ", stream);
+ gdb_puts (" = ", stream);
}
else if (! is_map || i % 2 == 0)
- fputs_filtered (pretty ? "," : ", ", stream);
+ gdb_puts (pretty ? "," : ", ", stream);
/* Skip printing children if max_depth has been reached. This check
is performed after print_string_repr and the "=" separator so that
goto done;
else if (i == 0)
/* Print initial "{" to bookend children. */
- fputs_filtered ("{", stream);
+ gdb_puts ("{", stream);
/* In summary mode, we just want to print "= {...}" if there is
a value. */
{
if (pretty)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
}
if (is_map && i % 2 == 0)
- fputs_filtered ("[", stream);
+ gdb_puts ("[", stream);
else if (is_array)
{
/* We print the index, not whatever the child method
}
else if (! is_map)
{
- fputs_filtered (name.get (), stream);
- fputs_filtered (" = ", stream);
+ gdb_puts (name.get (), stream);
+ gdb_puts (" = ", stream);
}
if (lsscm_is_lazy_string (v_scm))
{
gdb::unique_xmalloc_ptr<char> output
= gdbscm_scm_to_c_string (v_scm);
- fputs_filtered (output.get (), stream);
+ gdb_puts (output.get (), stream);
}
else
{
}
if (is_map && i % 2 == 0)
- fputs_filtered ("] = ", stream);
+ gdb_puts ("] = ", stream);
}
if (i)
{
if (pretty)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
- fputs_filtered ("...", stream);
+ gdb_puts ("...", stream);
}
if (pretty)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 * recurse, stream);
}
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
done:
fprintf_filtered (file, " %cInf", (sign ? '-' : '+'));
else if (sign && fraction[0] == 0x00000000 && fraction[1] == 0x40000000)
/* Real Indefinite (QNaN). */
- fputs_filtered (" Real Indefinite (QNaN)", file);
+ gdb_puts (" Real Indefinite (QNaN)", file);
else if (fraction[1] & 0x40000000)
/* QNaN. */
- fputs_filtered (" QNaN", file);
+ gdb_puts (" QNaN", file);
else
/* SNaN. */
- fputs_filtered (" SNaN", file);
+ gdb_puts (" SNaN", file);
}
else if (exponent < 0x7fff && exponent > 0x0000 && integer)
/* Normal. */
if (integer)
/* Pseudo-denormal. */
- fputs_filtered (" Pseudo-denormal", file);
+ gdb_puts (" Pseudo-denormal", file);
else if (fraction[0] || fraction[1])
/* Denormal. */
- fputs_filtered (" Denormal", file);
+ gdb_puts (" Denormal", file);
}
else
/* Unsupported. */
- fputs_filtered (" Unsupported", file);
+ gdb_puts (" Unsupported", file);
}
/* Print the status word STATUS. If STATUS_P is false, then STATUS
}
fprintf_filtered (file, "%s", hex_string_custom (status, 4));
- fputs_filtered (" ", file);
+ gdb_puts (" ", file);
fprintf_filtered (file, " %s", (status & 0x0001) ? "IE" : " ");
fprintf_filtered (file, " %s", (status & 0x0002) ? "DE" : " ");
fprintf_filtered (file, " %s", (status & 0x0004) ? "ZE" : " ");
fprintf_filtered (file, " %s", (status & 0x0008) ? "OE" : " ");
fprintf_filtered (file, " %s", (status & 0x0010) ? "UE" : " ");
fprintf_filtered (file, " %s", (status & 0x0020) ? "PE" : " ");
- fputs_filtered (" ", file);
+ gdb_puts (" ", file);
fprintf_filtered (file, " %s", (status & 0x0080) ? "ES" : " ");
- fputs_filtered (" ", file);
+ gdb_puts (" ", file);
fprintf_filtered (file, " %s", (status & 0x0040) ? "SF" : " ");
- fputs_filtered (" ", file);
+ gdb_puts (" ", file);
fprintf_filtered (file, " %s", (status & 0x0100) ? "C0" : " ");
fprintf_filtered (file, " %s", (status & 0x0200) ? "C1" : " ");
fprintf_filtered (file, " %s", (status & 0x0400) ? "C2" : " ");
fprintf_filtered (file, " %s", (status & 0x4000) ? "C3" : " ");
- fputs_filtered ("\n", file);
+ gdb_puts ("\n", file);
fprintf_filtered (file,
" TOP: %d\n", ((status >> 11) & 7));
}
fprintf_filtered (file, "%s", hex_string_custom (control, 4));
- fputs_filtered (" ", file);
+ gdb_puts (" ", file);
fprintf_filtered (file, " %s", (control & 0x0001) ? "IM" : " ");
fprintf_filtered (file, " %s", (control & 0x0002) ? "DM" : " ");
fprintf_filtered (file, " %s", (control & 0x0004) ? "ZM" : " ");
fprintf_filtered (file, " %s", (control & 0x0010) ? "UM" : " ");
fprintf_filtered (file, " %s", (control & 0x0020) ? "PM" : " ");
- fputs_filtered ("\n", file);
+ gdb_puts ("\n", file);
- fputs_filtered (" PC: ", file);
+ gdb_puts (" PC: ", file);
switch ((control >> 8) & 3)
{
case 0:
- fputs_filtered ("Single Precision (24-bits)\n", file);
+ gdb_puts ("Single Precision (24-bits)\n", file);
break;
case 1:
- fputs_filtered ("Reserved\n", file);
+ gdb_puts ("Reserved\n", file);
break;
case 2:
- fputs_filtered ("Double Precision (53-bits)\n", file);
+ gdb_puts ("Double Precision (53-bits)\n", file);
break;
case 3:
- fputs_filtered ("Extended Precision (64-bits)\n", file);
+ gdb_puts ("Extended Precision (64-bits)\n", file);
break;
}
- fputs_filtered (" RC: ", file);
+ gdb_puts (" RC: ", file);
switch ((control >> 10) & 3)
{
case 0:
- fputs_filtered ("Round to nearest\n", file);
+ gdb_puts ("Round to nearest\n", file);
break;
case 1:
- fputs_filtered ("Round down\n", file);
+ gdb_puts ("Round down\n", file);
break;
case 2:
- fputs_filtered ("Round up\n", file);
+ gdb_puts ("Round up\n", file);
break;
case 3:
- fputs_filtered ("Round toward zero\n", file);
+ gdb_puts ("Round toward zero\n", file);
break;
}
}
switch (tag)
{
case 0:
- fputs_filtered ("Valid ", file);
+ gdb_puts ("Valid ", file);
break;
case 1:
- fputs_filtered ("Zero ", file);
+ gdb_puts ("Zero ", file);
break;
case 2:
- fputs_filtered ("Special ", file);
+ gdb_puts ("Special ", file);
break;
case 3:
- fputs_filtered ("Empty ", file);
+ gdb_puts ("Empty ", file);
break;
}
}
else
- fputs_filtered ("Unknown ", file);
+ gdb_puts ("Unknown ", file);
regnum = (fpreg + 8 - top) % 8 + I387_ST0_REGNUM (tdep);
regval = get_frame_register_value (frame, regnum);
{
const gdb_byte *raw = value_contents (regval).data ();
- fputs_filtered ("0x", file);
+ gdb_puts ("0x", file);
for (i = 9; i >= 0; i--)
fprintf_filtered (file, "%02x", raw[i]);
else
fprintf_filtered (file, "%s", _("<unavailable>"));
- fputs_filtered ("\n", file);
+ gdb_puts ("\n", file);
}
}
- fputs_filtered ("\n", file);
+ gdb_puts ("\n", file);
print_i387_status_word (fstat_p, fstat, file);
print_i387_control_word (fctrl_p, fctrl, file);
fprintf_filtered (file, "Tag Word: %s\n",
if (from_tty)
{
printf_filtered (_("Continuing at "));
- puts_filtered (paddress (gdbarch, addr));
+ gdb_puts (paddress (gdbarch, addr));
printf_filtered (".\n");
}
if (val)
{
- puts_filtered (var);
- puts_filtered (" = ");
- puts_filtered (val);
- puts_filtered ("\n");
+ gdb_puts (var);
+ gdb_puts (" = ");
+ gdb_puts (val);
+ gdb_puts ("\n");
}
else
{
- puts_filtered ("Environment variable \"");
- puts_filtered (var);
- puts_filtered ("\" not defined.\n");
+ gdb_puts ("Environment variable \"");
+ gdb_puts (var);
+ gdb_puts ("\" not defined.\n");
}
}
else
for (int idx = 0; envp[idx] != NULL; ++idx)
{
- puts_filtered (envp[idx]);
- puts_filtered ("\n");
+ gdb_puts (envp[idx]);
+ gdb_puts ("\n");
}
}
}
static void
path_info (const char *args, int from_tty)
{
- puts_filtered ("Executable and object file path: ");
- puts_filtered (current_inferior ()->environment.get (path_var_name));
- puts_filtered ("\n");
+ gdb_puts ("Executable and object file path: ");
+ gdb_puts (current_inferior ()->environment.get (path_var_name));
+ gdb_puts ("\n");
}
/* Add zero or more directories to the front of the execution path. */
}
}
- fputs_filtered (format_stream.c_str (), file);
+ gdb_puts (format_stream.c_str (), file);
fprintf_filtered (file, "\n");
}
"virtual address space is %s.\n"),
value);
else
- fputs_filtered (_("Disabling randomization of debuggee's "
- "virtual address space is unsupported on\n"
- "this platform.\n"), file);
+ gdb_puts (_("Disabling randomization of debuggee's "
+ "virtual address space is unsupported on\n"
+ "this platform.\n"), file);
}
static void
(code_entry->symfile_addr, code_entry->symfile_size, gnutarget));
if (nbfd == NULL)
{
- fputs_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"),
- gdb_stderr);
+ gdb_puts (_("Error opening JITed symbol file, ignoring it.\n"),
+ gdb_stderr);
return;
}
if (fi.num == 0)
printf_filtered (_(" (main process)"));
printf_filtered (_(" at "));
- puts_filtered (paddress (gdbarch, pc));
+ gdb_puts (paddress (gdbarch, pc));
symtab_and_line sal = find_pc_line (pc, 0);
if (sal.symtab)
gdb::unique_xmalloc_ptr<char> status
= target_fileio_read_stralloc (NULL, filename);
if (status)
- puts_filtered (status.get ());
+ gdb_puts (status.get ());
else
warning (_("unable to open /proc file '%s'"), filename);
}
catch (const gdb_exception_error &except)
{
if (warning_pre_print)
- fputs_unfiltered (warning_pre_print, gdb_stderr);
+ gdb_puts (warning_pre_print, gdb_stderr);
exception_fprintf (gdb_stderr, except,
_("libthread_db integrity checks failed: "));
m2_language::printchar (int c, struct type *type,
struct ui_file *stream) const
{
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
emitchar (c, type, stream, '\'');
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
}
/* See language.h. */
if (length == 0)
{
- puts_filtered ("\"\"");
+ gdb_puts ("\"\"");
return;
}
if (need_comma)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
need_comma = 0;
}
{
if (in_quotes)
{
- fputs_filtered ("\", ", stream);
+ gdb_puts ("\", ", stream);
in_quotes = 0;
}
printchar (string[i], elttype, stream);
{
if (!in_quotes)
{
- fputs_filtered ("\"", stream);
+ gdb_puts ("\"", stream);
in_quotes = 1;
}
emitchar (string[i], elttype, stream, '"');
/* Terminate the quotes if necessary. */
if (in_quotes)
- fputs_filtered ("\"", stream);
+ gdb_puts ("\"", stream);
if (force_ellipses || i < length)
- fputs_filtered ("...", stream);
+ gdb_puts ("...", stream);
}
/* See language.h. */
if (PRINT_LITERAL_FORM (ch))
{
if (ch == '\\' || ch == quoter)
- fputs_filtered ("\\", stream);
+ gdb_puts ("\\", stream);
fprintf_filtered (stream, "%c", ch);
}
else
switch (ch)
{
case '\n':
- fputs_filtered ("\\n", stream);
+ gdb_puts ("\\n", stream);
break;
case '\b':
- fputs_filtered ("\\b", stream);
+ gdb_puts ("\\b", stream);
break;
case '\t':
- fputs_filtered ("\\t", stream);
+ gdb_puts ("\\t", stream);
break;
case '\f':
- fputs_filtered ("\\f", stream);
+ gdb_puts ("\\f", stream);
break;
case '\r':
- fputs_filtered ("\\r", stream);
+ gdb_puts ("\\r", stream);
break;
case '\033':
- fputs_filtered ("\\e", stream);
+ gdb_puts ("\\e", stream);
break;
case '\007':
- fputs_filtered ("\\a", stream);
+ gdb_puts ("\\a", stream);
break;
default:
fprintf_filtered (stream, "\\%.3o", (unsigned int) ch);
m2_type_name (struct type *type, struct ui_file *stream)
{
if (type->name () != NULL)
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
}
/* m2_range - displays a Modula-2 subrange type. */
{
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
- fputs_filtered (" = ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (" = ", stream);
}
m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
}
m2_print_bounds (type->index_type (), stream, show, -1, 1);
}
else
- fputs_filtered (pulongest ((TYPE_LENGTH (type)
- / TYPE_LENGTH (TYPE_TARGET_TYPE (type)))),
- stream);
+ gdb_puts (pulongest ((TYPE_LENGTH (type)
+ / TYPE_LENGTH (TYPE_TARGET_TYPE (type)))),
+ stream);
}
fprintf_filtered (stream, "] OF ");
m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
{
if (i > 0)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
stream->wrap_here (4);
}
m2_print_type (type->field (i).type (), "", stream, -1, 0, flags);
{
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
if (show == 0)
return 1;
- fputs_filtered (" = ", stream);
+ gdb_puts (" = ", stream);
}
if (get_long_set_bounds (type, &low, &high))
{
if (show > 0)
{
- fputs_filtered ("ARRAY OF ", stream);
+ gdb_puts ("ARRAY OF ", stream);
m2_print_type (TYPE_TARGET_TYPE (type->field (0).type ()),
"", stream, 0, level, flags);
}
{
if (!startswith (type->name (), "$$"))
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
if (show > 0)
fprintf_filtered (stream, " = ");
}
print_spaces_filtered (level + 4, stream);
fputs_styled (type->field (i).name (),
variable_name_style.style (), stream);
- fputs_filtered (" : ", stream);
+ gdb_puts (" : ", stream);
m2_print_type (type->field (i).type (),
"",
stream, 0, level + 4, flags);
if (options->addressprint && options->format != 's')
{
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_puts (paddress (gdbarch, address), stream);
want_space = 1;
}
&& addr != 0)
{
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
stream, options);
}
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
fprintf_filtered (stream, "[");
- fputs_filtered (paddress (gdbarch, addr), stream);
+ gdb_puts (paddress (gdbarch, addr), stream);
fprintf_filtered (stream, "] : ");
if (elttype->code () != TYPE_CODE_UNDEF)
common_val_print (deref_val, stream, recurse, options, current_language);
}
else
- fputs_filtered ("???", stream);
+ gdb_puts ("???", stream);
}
int i;
int need_comma = 0;
- fputs_filtered ("{", stream);
+ gdb_puts ("{", stream);
i = get_discrete_bounds (range, &low_bound, &high_bound) ? 0 : -1;
maybe_bad_bstring:
if (element)
{
if (need_comma)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
print_type_scalar (range, i, stream);
need_comma = 1;
{
int j = i;
- fputs_filtered ("..", stream);
+ gdb_puts ("..", stream);
while (i + 1 <= high_bound
&& value_bit_index (type, valaddr, ++i))
j = i;
}
}
done:
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
break;
static void
macro_inform_no_debuginfo (void)
{
- puts_filtered ("GDB has no preprocessor macro information for that code.\n");
+ gdb_puts ("GDB has no preprocessor macro information for that code.\n");
}
static void
{
gdb::unique_xmalloc_ptr<char> expanded = macro_expand (exp, *ms);
- puts_filtered ("expands to: ");
- puts_filtered (expanded.get ());
- puts_filtered ("\n");
+ gdb_puts ("expands to: ");
+ gdb_puts (expanded.get ());
+ gdb_puts ("\n");
}
else
macro_inform_no_debuginfo ();
{
gdb::unique_xmalloc_ptr<char> expanded = macro_expand_once (exp, *ms);
- puts_filtered ("expands to: ");
- puts_filtered (expanded.get ());
- puts_filtered ("\n");
+ gdb_puts ("expands to: ");
+ gdb_puts (expanded.get ());
+ gdb_puts ("\n");
}
else
macro_inform_no_debuginfo ();
while (file->included_by)
{
fullname = macro_source_fullname (file->included_by);
- fputs_filtered (_(" included at "), stream);
+ gdb_puts (_(" included at "), stream);
fputs_styled (fullname.c_str (), file_name_style.style (), stream);
fprintf_filtered (stream, ":%d\n", file->included_at_line);
file = file->included_by;
{
int i;
- puts_filtered ("(");
+ gdb_puts ("(");
for (i = 0; i < d->argc; i++)
{
- puts_filtered (d->argv[i]);
+ gdb_puts (d->argv[i]);
if (i + 1 < d->argc)
- puts_filtered (", ");
+ gdb_puts (", ");
}
- puts_filtered (")");
+ gdb_puts (")");
}
if (line != 0)
/* Note: The options in the list below are only approximately sorted
in the alphabetical order, so as to group closely related options
together. */
- fputs_unfiltered (_("\
+ gdb_puts (_("\
This is the GNU debugger. Usage:\n\n\
gdb [options] [executable-file [core-file or process-id]]\n\
gdb [options] --args executable-file [inferior-arguments ...]\n\n\
"), stream);
- fputs_unfiltered (_("\
+ gdb_puts (_("\
Selection of debuggee and its files:\n\n\
--args Arguments after executable-file are passed to inferior.\n\
--core=COREFILE Analyze the core dump COREFILE.\n\
--readnever Do not read symbol files.\n\
--write Set writing into executable and core files.\n\n\
"), stream);
- fputs_unfiltered (_("\
+ gdb_puts (_("\
Initial commands and command files:\n\n\
--command=FILE, -x Execute GDB commands from FILE.\n\
--init-command=FILE, -ix\n\
--nh Do not read ~/.gdbinit.\n\
--nx Do not read any .gdbinit files in any directory.\n\n\
"), stream);
- fputs_unfiltered (_("\
+ gdb_puts (_("\
Output and user interface control:\n\n\
--fullname Output information used by emacs-GDB interface.\n\
--interpreter=INTERP\n\
--nw Do not use the GUI interface.\n\
"), stream);
#if defined(TUI)
- fputs_unfiltered (_("\
+ gdb_puts (_("\
--tui Use a terminal user interface.\n\
"), stream);
#endif
- fputs_unfiltered (_("\
+ gdb_puts (_("\
--dbx DBX compatibility mode.\n\
-q, --quiet, --silent\n\
Do not print version number on startup.\n\n\
"), stream);
- fputs_unfiltered (_("\
+ gdb_puts (_("\
Operating modes:\n\n\
--batch Exit after processing options.\n\
--batch-silent Like --batch, but suppress all gdb stdout output.\n\
--data-directory=DIR, -D\n\
Set GDB's data-directory to DIR.\n\
"), stream);
- fputs_unfiltered (_("\n\
+ gdb_puts (_("\n\
At startup, GDB reads the following early init files and executes their\n\
commands:\n\
"), stream);
if (home_gdbearlyinit.empty ())
fprintf_unfiltered (stream, _("\
None found.\n"));
- fputs_unfiltered (_("\n\
+ gdb_puts (_("\n\
At startup, GDB reads the following init files and executes their commands:\n\
"), stream);
if (!system_gdbinit.empty ())
&& local_gdbinit.empty ())
fprintf_unfiltered (stream, _("\
None found.\n"));
- fputs_unfiltered (_("\n\
+ gdb_puts (_("\n\
For more information, type \"help\" from within GDB, or consult the\n\
GDB manual (available as on-line info or a printed manual).\n\
"), stream);
maintenance_show_test_options_completion_result (const char *args,
int from_tty)
{
- puts_filtered (maintenance_test_options_command_completion_text.c_str ());
+ gdb_puts (maintenance_test_options_command_completion_text.c_str ());
}
/* Save the completion result in the global variables read by the
maint_print_all_sections (const char *header, bfd *abfd, objfile *objfile,
const char *arg)
{
- puts_filtered (header);
+ gdb_puts (header);
gdb_stdout->wrap_here (8);
printf_filtered ("`%s', ", bfd_get_filename (abfd));
gdb_stdout->wrap_here (8);
)
for i in range(len(argtypes)):
if i > 0:
- print(' fputs_unfiltered (", ", gdb_stdlog);', file=f)
+ print(' gdb_puts (", ", gdb_stdlog);', file=f)
printer = munge_type(argtypes[i])
print(" " + printer + " (" + names[i] + ");", file=f)
if return_type != "void":
- print(' fputs_unfiltered (") = ", gdb_stdlog);', file=f)
+ print(' gdb_puts (") = ", gdb_stdlog);', file=f)
printer = munge_type(return_type)
print(" " + printer + " (result);", file=f)
- print(' fputs_unfiltered ("\\n", gdb_stdlog);', file=f)
+ print(' gdb_puts ("\\n", gdb_stdlog);', file=f)
else:
- print(' fputs_unfiltered (")\\n", gdb_stdlog);', file=f)
+ print(' gdb_puts (")\\n", gdb_stdlog);', file=f)
if return_type != "void":
print(" return result;", file=f)
size_t length_buf = str.size ();
const char *buf = str.data ();
- fputs_unfiltered (m_prefix, m_raw);
+ gdb_puts (m_prefix, m_raw);
if (m_quote)
{
fputc_unfiltered (m_quote, m_raw);
{
struct ui *ui = current_ui;
- fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
+ gdb_puts ("(gdb) \n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
ui->prompt_state = PROMPTED;
}
mi_uiout->field_signed ("core", core);
}
- fputs_unfiltered ("*stopped", mi->raw_stdout);
+ gdb_puts ("*stopped", mi->raw_stdout);
mi_out_put (mi_uiout, mi->raw_stdout);
mi_out_rewind (mi_uiout);
mi_print_timing_maybe (mi->raw_stdout);
- fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_puts ("\n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
}
even if it cannot actually accept any input. This will be
surely removed for MI3, and may be removed even earlier. */
if (current_ui->prompt_state == PROMPT_BLOCKED)
- fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
+ gdb_puts ("(gdb) \n", mi->raw_stdout);
}
gdb_flush (mi->raw_stdout);
}
/* We have to print everything right here because we never return. */
if (current_token)
- fputs_unfiltered (current_token, mi->raw_stdout);
- fputs_unfiltered ("^exit\n", mi->raw_stdout);
+ gdb_puts (current_token, mi->raw_stdout);
+ gdb_puts ("^exit\n", mi->raw_stdout);
mi_out_put (current_uiout, mi->raw_stdout);
gdb_flush (mi->raw_stdout);
/* FIXME: The function called is not yet a formal libgdb function. */
uiout will most likely crash in the mi_out_* routines. */
if (!running_result_record_printed)
{
- fputs_unfiltered (context->token, mi->raw_stdout);
+ gdb_puts (context->token, mi->raw_stdout);
/* There's no particularly good reason why target-connect results
in not ^done. Should kill ^connected for MI3. */
- fputs_unfiltered (strcmp (context->command, "target-select") == 0
- ? "^connected" : "^done", mi->raw_stdout);
+ gdb_puts (strcmp (context->command, "target-select") == 0
+ ? "^connected" : "^done", mi->raw_stdout);
mi_out_put (uiout, mi->raw_stdout);
mi_out_rewind (uiout);
mi_print_timing_maybe (mi->raw_stdout);
- fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_puts ("\n", mi->raw_stdout);
}
else
/* The command does not want anything to be printed. In that
{
if (!running_result_record_printed)
{
- fputs_unfiltered (context->token, mi->raw_stdout);
- fputs_unfiltered ("^done", mi->raw_stdout);
+ gdb_puts (context->token, mi->raw_stdout);
+ gdb_puts ("^done", mi->raw_stdout);
mi_out_put (uiout, mi->raw_stdout);
mi_out_rewind (uiout);
mi_print_timing_maybe (mi->raw_stdout);
- fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_puts ("\n", mi->raw_stdout);
}
else
mi_out_rewind (uiout);
{
struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
- fputs_unfiltered (token, mi->raw_stdout);
- fputs_unfiltered ("^error,msg=\"", mi->raw_stdout);
+ gdb_puts (token, mi->raw_stdout);
+ gdb_puts ("^error,msg=\"", mi->raw_stdout);
if (exception.message == NULL)
- fputs_unfiltered ("unknown error", mi->raw_stdout);
+ gdb_puts ("unknown error", mi->raw_stdout);
else
mi->raw_stdout->putstr (exception.what (), '"');
- fputs_unfiltered ("\"", mi->raw_stdout);
+ gdb_puts ("\"", mi->raw_stdout);
switch (exception.error)
{
case UNDEFINED_COMMAND_ERROR:
- fputs_unfiltered (",code=\"undefined-command\"", mi->raw_stdout);
+ gdb_puts (",code=\"undefined-command\"", mi->raw_stdout);
break;
}
- fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_puts ("\n", mi->raw_stdout);
}
void
previous_sect_name = xstrdup (section_name);
if (current_token)
- fputs_unfiltered (current_token, mi->raw_stdout);
- fputs_unfiltered ("+download", mi->raw_stdout);
+ gdb_puts (current_token, mi->raw_stdout);
+ gdb_puts ("+download", mi->raw_stdout);
{
ui_out_emit_tuple tuple_emitter (uiout.get (), NULL);
uiout->field_string ("section", section_name);
uiout->field_signed ("total-size", grand_total);
}
mi_out_put (uiout.get (), mi->raw_stdout);
- fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_puts ("\n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
}
{
last_update = time_now;
if (current_token)
- fputs_unfiltered (current_token, mi->raw_stdout);
- fputs_unfiltered ("+download", mi->raw_stdout);
+ gdb_puts (current_token, mi->raw_stdout);
+ gdb_puts ("+download", mi->raw_stdout);
{
ui_out_emit_tuple tuple_emitter (uiout.get (), NULL);
uiout->field_string ("section", section_name);
uiout->field_signed ("total-size", grand_total);
}
mi_out_put (uiout.get (), mi->raw_stdout);
- fputs_unfiltered ("\n", mi->raw_stdout);
+ gdb_puts ("\n", mi->raw_stdout);
gdb_flush (mi->raw_stdout);
}
}
if (fldname)
fprintf_unfiltered (stream, "%s=\"", fldname);
else
- fputs_unfiltered ("\"", stream);
+ gdb_puts ("\"", stream);
gdb_vprintf (stream, format, args);
- fputs_unfiltered ("\"", stream);
+ gdb_puts ("\"", stream);
}
void
{
int i;
- fputs_unfiltered (func, gdb_stdlog);
+ gdb_puts (func, gdb_stdlog);
if (addr || len)
fprintf_unfiltered (gdb_stdlog,
" (addr=%s, len=%d, type=%s)",
: (type == hw_access ? "data-read/write"
: (type == hw_execute ? "instruction-execute"
: "??unknown??"))));
- fputs_unfiltered (":\n", gdb_stdlog);
+ gdb_puts (":\n", gdb_stdlog);
for (i = 0; i < MAX_DEBUG_REGISTER; i++)
fprintf_unfiltered (gdb_stdlog, "\tDR%d: lo=%s, hi=%s\n", i,
val = get_frame_register_value (frame, regnum);
- fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
+ gdb_puts (gdbarch_register_name (gdbarch, regnum), file);
/* The problem with printing numeric register names (r26, etc.) is that
the user can't use them on input. Probably the best solution is to
print_fpu_flags (struct ui_file *file, int flags)
{
if (flags & (1 << 0))
- fputs_filtered (" inexact", file);
+ gdb_puts (" inexact", file);
if (flags & (1 << 1))
- fputs_filtered (" uflow", file);
+ gdb_puts (" uflow", file);
if (flags & (1 << 2))
- fputs_filtered (" oflow", file);
+ gdb_puts (" oflow", file);
if (flags & (1 << 3))
- fputs_filtered (" div0", file);
+ gdb_puts (" div0", file);
if (flags & (1 << 4))
- fputs_filtered (" inval", file);
+ gdb_puts (" inval", file);
if (flags & (1 << 5))
- fputs_filtered (" unimp", file);
+ gdb_puts (" unimp", file);
fputc_filtered ('\n', file);
}
fprintf_filtered (file, "reg size: %d bits\n",
register_size (gdbarch, mips_regnum (gdbarch)->fp0) * 8);
- fputs_filtered ("cond :", file);
+ gdb_puts ("cond :", file);
if (fcs & (1 << 23))
- fputs_filtered (" 0", file);
+ gdb_puts (" 0", file);
for (i = 1; i <= 7; i++)
if (fcs & (1 << (24 + i)))
fprintf_filtered (file, " %d", i);
fputc_filtered ('\n', file);
- fputs_filtered ("cause :", file);
+ gdb_puts ("cause :", file);
print_fpu_flags (file, (fcs >> 12) & 0x3f);
fputs ("mask :", stdout);
print_fpu_flags (file, (fcs >> 7) & 0x1f);
fputs ("flags :", stdout);
print_fpu_flags (file, (fcs >> 2) & 0x1f);
- fputs_filtered ("rounding: ", file);
+ gdb_puts ("rounding: ", file);
switch (fcs & 3)
{
- case 0: fputs_filtered ("nearest\n", file); break;
- case 1: fputs_filtered ("zero\n", file); break;
- case 2: fputs_filtered ("+inf\n", file); break;
- case 3: fputs_filtered ("-inf\n", file); break;
+ case 0: gdb_puts ("nearest\n", file); break;
+ case 1: gdb_puts ("zero\n", file); break;
+ case 2: gdb_puts ("+inf\n", file); break;
+ case 3: gdb_puts ("-inf\n", file); break;
}
- fputs_filtered ("flush :", file);
+ gdb_puts ("flush :", file);
if (fcs & (1 << 21))
- fputs_filtered (" nearest", file);
+ gdb_puts (" nearest", file);
if (fcs & (1 << 22))
- fputs_filtered (" override", file);
+ gdb_puts (" override", file);
if (fcs & (1 << 24))
- fputs_filtered (" zero", file);
+ gdb_puts (" zero", file);
if ((fcs & (0xb << 21)) == 0)
- fputs_filtered (" no", file);
+ gdb_puts (" no", file);
fputc_filtered ('\n', file);
fprintf_filtered (file, "nan2008 : %s\n", fcs & (1 << 18) ? "yes" : "no");
if (c == '\'' || ((unsigned int) c <= 0xff && (PRINT_LITERAL_FORM (c))))
{
if (!(*in_quotes))
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
*in_quotes = 1;
if (c == '\'')
{
- fputs_filtered ("''", stream);
+ gdb_puts ("''", stream);
}
else
fprintf_filtered (stream, "%c", c);
else
{
if (*in_quotes)
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
*in_quotes = 0;
fprintf_filtered (stream, "#%d", (unsigned int) c);
}
print_one_char (c, stream, &in_quotes);
if (in_quotes)
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
}
\f
if (length == 0)
{
- fputs_filtered ("''", stream);
+ gdb_puts ("''", stream);
return;
}
if (need_comma)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
need_comma = 0;
}
{
if (in_quotes)
{
- fputs_filtered ("', ", stream);
+ gdb_puts ("', ", stream);
in_quotes = 0;
}
printchar (current_char, elttype, stream);
{
if ((!in_quotes) && (PRINT_LITERAL_FORM (current_char)))
{
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
in_quotes = 1;
}
print_one_char (current_char, stream, &in_quotes);
/* Terminate the quotes if necessary. */
if (in_quotes)
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
if (force_ellipses || i < length)
- fputs_filtered ("...", stream);
+ gdb_puts ("...", stream);
}
/* Single instance of the Pascal language class. */
print_one_char (ch, stream, &in_quotes);
if (in_quotes)
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
}
/* See language.h. */
type_print_varspec_prefix (type, stream, show, 0, flags);
}
/* first the name */
- fputs_filtered (varstring, stream);
+ gdb_puts (varstring, stream);
if ((varstring != NULL && *varstring != '\0')
&& !(code == TYPE_CODE_FUNC
|| code == TYPE_CODE_METHOD))
{
- fputs_filtered (" : ", stream);
+ gdb_puts (" : ", stream);
}
if (!(code == TYPE_CODE_FUNC
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- fputs_filtered (i == 0 ? ": " : ", ", stream);
+ gdb_puts (i == 0 ? ": " : ", ", stream);
fprintf_filtered (stream, "%s%s ",
BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private",
BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
}
if (i > 0)
{
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
}
physname += 6;
}
- fputs_filtered (methodname, stream);
+ gdb_puts (methodname, stream);
if (physname && (*physname != 0))
{
- fputs_filtered (" (", stream);
+ gdb_puts (" (", stream);
/* We must demangle this. */
while (isdigit (physname[0]))
{
physname += i;
if (physname[0] != 0)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
}
}
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
}
{
if (i > 0)
{
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
stream->wrap_here (4);
}
/* Can we find if it is a var parameter ??
if ((type->code () == TYPE_CODE_PTR)
&& (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID))
{
- fputs_filtered (type->name () ? type->name () : "pointer",
- stream);
+ gdb_puts (type->name () ? type->name () : "pointer",
+ stream);
return;
}
/* When SHOW is zero or less, and there is a valid type name, then always
if (show <= 0
&& type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
return;
}
case TYPE_CODE_STRUCT:
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
- fputs_filtered (" = ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (" = ", stream);
}
if (HAVE_CPLUS_STRUCT (type))
{
case TYPE_CODE_UNION:
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
- fputs_filtered (" = ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (" = ", stream);
}
fprintf_filtered (stream, "case <?> of ");
if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) != 0
&& TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE(f, j))->code () != TYPE_CODE_VOID)
{
- fputs_filtered (" : ", stream);
+ gdb_puts (" : ", stream);
type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
"", stream, -1);
}
case TYPE_CODE_ENUM:
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
if (show > 0)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
/* enum is just defined by
type enume_name = (enum_member1,enum_member2,...) */
if (i)
fprintf_filtered (stream, ", ");
stream->wrap_here (4);
- fputs_filtered (type->field (i).name (), stream);
+ gdb_puts (type->field (i).name (), stream);
if (lastval != type->field (i).loc_enumval ())
{
fprintf_filtered (stream,
struct type *target = TYPE_TARGET_TYPE (type);
print_type_scalar (target, type->bounds ()->low.const_val (), stream);
- fputs_filtered ("..", stream);
+ gdb_puts ("..", stream);
print_type_scalar (target, type->bounds ()->high.const_val (), stream);
}
break;
case TYPE_CODE_SET:
- fputs_filtered ("set of ", stream);
+ gdb_puts ("set of ", stream);
print_type (type->index_type (), "", stream,
show - 1, level, flags);
break;
case TYPE_CODE_STRING:
- fputs_filtered ("String", stream);
+ gdb_puts ("String", stream);
break;
default:
is no type name, then complain. */
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
}
else
{
if (options->addressprint && options->format != 's')
{
- fputs_filtered (paddress (gdbarch, addr), stream);
+ gdb_puts (paddress (gdbarch, addr), stream);
want_space = 1;
}
&& addr != 0)
{
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
/* No wide string yet. */
i = val_print_string (elttype, NULL, addr, -1, stream, options);
}
gdb_byte *buffer;
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
buffer = (gdb_byte *) xmalloc (length_size);
read_memory (addr + length_pos, buffer, length_size);
string_length = extract_unsigned_integer (buffer, length_size,
&& (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol)))
{
if (want_space)
- fputs_filtered (" ", stream);
- fputs_filtered ("<", stream);
- fputs_filtered (msymbol.minsym->print_name (), stream);
- fputs_filtered (">", stream);
+ gdb_puts (" ", stream);
+ gdb_puts ("<", stream);
+ gdb_puts (msymbol.minsym->print_name (), stream);
+ gdb_puts (">", stream);
want_space = 1;
}
if (vt_address && options->vtblprint)
struct type *wtype;
if (want_space)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
if (msymbol.minsym != NULL)
{
LONGEST low_bound, high_bound;
int need_comma = 0;
- fputs_filtered ("[", stream);
+ gdb_puts ("[", stream);
int bound_info = (get_discrete_bounds (range, &low_bound, &high_bound)
? 0 : -1);
if (element)
{
if (need_comma)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
print_type_scalar (range, i, stream);
need_comma = 1;
{
int j = i;
- fputs_filtered ("..", stream);
+ gdb_puts ("..", stream);
while (i + 1 <= high_bound
&& value_bit_index (type, valaddr, ++i))
j = i;
}
}
done:
- fputs_filtered ("]", stream);
+ gdb_puts ("]", stream);
}
break;
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
- fputs_filtered ("members of ", stream);
- fputs_filtered (type->name (), stream);
- fputs_filtered (": ", stream);
+ gdb_puts ("members of ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (": ", stream);
}
}
fields_seen = 1;
if (field_is_static (&type->field (i)))
{
- fputs_filtered ("static ", stream);
+ gdb_puts ("static ", stream);
fprintf_symbol_filtered (stream,
type->field (i).name (),
current_language->la_language,
fputs_styled (type->field (i).name (),
variable_name_style.style (), stream);
annotate_field_name_end ();
- fputs_filtered (" = ", stream);
+ gdb_puts (" = ", stream);
annotate_field_value ();
if (!field_is_static (&type->field (i))
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
- fputs_filtered ("<", stream);
+ gdb_puts ("<", stream);
/* Not sure what the best notation is in the case where there is no
baseclass name. */
- fputs_filtered (basename ? basename : "", stream);
- fputs_filtered ("> = ", stream);
+ gdb_puts (basename ? basename : "", stream);
+ gdb_puts ("> = ", stream);
if (skip < 0)
val_print_unavailable (stream);
(base_value, stream, recurse, options,
(struct type **) obstack_base (&dont_print_vb_obstack),
0);
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
flush_it:
;
&offset, &filename, &line, &unmapped))
return 0;
- fputs_filtered (leadin, stream);
+ gdb_puts (leadin, stream);
if (unmapped)
- fputs_filtered ("<*", stream);
+ gdb_puts ("<*", stream);
else
- fputs_filtered ("<", stream);
+ gdb_puts ("<", stream);
fputs_styled (name.c_str (), function_name_style.style (), stream);
if (offset != 0)
fprintf_filtered (stream, "%+d", offset);
line # of this addr, if we have it; else line # of the nearest symbol. */
if (print_symbol_filename && !filename.empty ())
{
- fputs_filtered (line == -1 ? " in " : " at ", stream);
+ gdb_puts (line == -1 ? " in " : " at ", stream);
fputs_styled (filename.c_str (), file_name_style.style (), stream);
if (line != -1)
fprintf_filtered (stream, ":%d", line);
}
if (unmapped)
- fputs_filtered ("*>", stream);
+ gdb_puts ("*>", stream);
else
- fputs_filtered (">", stream);
+ gdb_puts (">", stream);
return 1;
}
}
if (format == 'i')
- puts_filtered (pc_prefix (next_address));
+ gdb_puts (pc_prefix (next_address));
print_address (next_gdbarch, next_address, gdb_stdout);
printf_filtered (":");
for (i = maxelts;
}
printf_filtered ("Symbol \"");
- puts_filtered (sym->print_name ());
+ gdb_puts (sym->print_name ());
printf_filtered ("\" is ");
val = SYMBOL_VALUE (sym);
if (sym->is_objfile_owned ())
annotate_display_expression ();
- puts_filtered (d->exp_string.c_str ());
+ gdb_puts (d->exp_string.c_str ());
annotate_display_expression_end ();
if (d->format.count != 1 || d->format.format == 'i')
annotate_display_expression ();
- puts_filtered (d->exp_string.c_str ());
+ gdb_puts (d->exp_string.c_str ());
annotate_display_expression_end ();
printf_filtered (" = ");
d->format.format);
else if (d->format.format)
printf_filtered ("/%c ", d->format.format);
- puts_filtered (d->exp_string.c_str ());
+ gdb_puts (d->exp_string.c_str ());
if (d->block && !contained_in (get_selected_block (0), d->block, true))
printf_filtered (_(" (cannot be evaluated in the current context)"));
printf_filtered ("\n");
/* Convert the value to a string and print it. */
std::string str
= target_float_to_string (value_contents (value).data (), fmt_type, format);
- fputs_filtered (str.c_str (), stream);
+ gdb_puts (str.c_str (), stream);
}
/* Subroutine of ui_printf to simplify it.
/* Print a portion of the format string that has no
directives. Note that this will not include any
ordinary %-specs, but it might include "%%". That is
- why we use printf_filtered and not puts_filtered here.
+ why we use printf_filtered and not gdb_puts here.
Also, we pass a dummy argument because some platforms
have modified GCC to include -Wformat-security by
default, which will warn here if there is no
fprintf_filtered (outfile, " `%s'",
p->ginfo.demangled_name ());
}
- fputs_filtered (", ", outfile);
+ gdb_puts (", ", outfile);
switch (p->domain)
{
case UNDEF_DOMAIN:
- fputs_filtered ("undefined domain, ", outfile);
+ gdb_puts ("undefined domain, ", outfile);
break;
case VAR_DOMAIN:
/* This is the usual thing -- don't print it. */
break;
case STRUCT_DOMAIN:
- fputs_filtered ("struct domain, ", outfile);
+ gdb_puts ("struct domain, ", outfile);
break;
case MODULE_DOMAIN:
- fputs_filtered ("module domain, ", outfile);
+ gdb_puts ("module domain, ", outfile);
break;
case LABEL_DOMAIN:
- fputs_filtered ("label domain, ", outfile);
+ gdb_puts ("label domain, ", outfile);
break;
case COMMON_BLOCK_DOMAIN:
- fputs_filtered ("common block domain, ", outfile);
+ gdb_puts ("common block domain, ", outfile);
break;
default:
- fputs_filtered ("<invalid domain>, ", outfile);
+ gdb_puts ("<invalid domain>, ", outfile);
break;
}
switch (p->aclass)
{
case LOC_UNDEF:
- fputs_filtered ("undefined", outfile);
+ gdb_puts ("undefined", outfile);
break;
case LOC_CONST:
- fputs_filtered ("constant int", outfile);
+ gdb_puts ("constant int", outfile);
break;
case LOC_STATIC:
- fputs_filtered ("static", outfile);
+ gdb_puts ("static", outfile);
break;
case LOC_REGISTER:
- fputs_filtered ("register", outfile);
+ gdb_puts ("register", outfile);
break;
case LOC_ARG:
- fputs_filtered ("pass by value", outfile);
+ gdb_puts ("pass by value", outfile);
break;
case LOC_REF_ARG:
- fputs_filtered ("pass by reference", outfile);
+ gdb_puts ("pass by reference", outfile);
break;
case LOC_REGPARM_ADDR:
- fputs_filtered ("register address parameter", outfile);
+ gdb_puts ("register address parameter", outfile);
break;
case LOC_LOCAL:
- fputs_filtered ("stack parameter", outfile);
+ gdb_puts ("stack parameter", outfile);
break;
case LOC_TYPEDEF:
- fputs_filtered ("type", outfile);
+ gdb_puts ("type", outfile);
break;
case LOC_LABEL:
- fputs_filtered ("label", outfile);
+ gdb_puts ("label", outfile);
break;
case LOC_BLOCK:
- fputs_filtered ("function", outfile);
+ gdb_puts ("function", outfile);
break;
case LOC_CONST_BYTES:
- fputs_filtered ("constant bytes", outfile);
+ gdb_puts ("constant bytes", outfile);
break;
case LOC_UNRESOLVED:
- fputs_filtered ("unresolved", outfile);
+ gdb_puts ("unresolved", outfile);
break;
case LOC_OPTIMIZED_OUT:
- fputs_filtered ("optimized out", outfile);
+ gdb_puts ("optimized out", outfile);
break;
case LOC_COMPUTED:
- fputs_filtered ("computed at runtime", outfile);
+ gdb_puts ("computed at runtime", outfile);
break;
default:
- fputs_filtered ("<invalid location>", outfile);
+ gdb_puts ("<invalid location>", outfile);
break;
}
- fputs_filtered (", ", outfile);
- fputs_filtered (paddress (gdbarch, p->unrelocated_address ()), outfile);
+ gdb_puts (", ", outfile);
+ gdb_puts (paddress (gdbarch, p->unrelocated_address ()), outfile);
fprintf_filtered (outfile, "\n");
}
}
host_address_to_string (psymtab->get_compunit_symtab (objfile)));
fprintf_filtered (outfile, " Symbols cover text addresses ");
- fputs_filtered (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
+ gdb_puts (paddress (gdbarch, psymtab->text_low (objfile)), outfile);
fprintf_filtered (outfile, "-");
- fputs_filtered (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
+ gdb_puts (paddress (gdbarch, psymtab->text_high (objfile)), outfile);
fprintf_filtered (outfile, "\n");
fprintf_filtered (outfile, " Address map supported - %s.\n",
psymtab->psymtabs_addrmap_supported ? "yes" : "no");
/* Inform about additional files to be read in. */
if (info_verbose)
{
- puts_filtered (" ");
+ gdb_puts (" ");
gdb_stdout->wrap_here (0);
- puts_filtered ("and ");
+ gdb_puts ("and ");
gdb_stdout->wrap_here (0);
printf_filtered ("%s...", dependencies[i]->filename);
gdb_stdout->wrap_here (0); /* Flush output */
psymtab->fullname
? psymtab->fullname : "(null)");
printf_filtered (" text addresses ");
- puts_filtered (paddress (gdbarch,
- psymtab->text_low (objfile)));
+ gdb_puts (paddress (gdbarch,
+ psymtab->text_low (objfile)));
printf_filtered (" -- ");
- puts_filtered (paddress (gdbarch,
- psymtab->text_high (objfile)));
+ gdb_puts (paddress (gdbarch,
+ psymtab->text_high (objfile)));
printf_filtered ("\n");
printf_filtered (" psymtabs_addrmap_supported %s\n",
(psymtab->psymtabs_addrmap_supported
if (ps->text_high (objfile) < ps->text_low (objfile))
{
printf_filtered ("Psymtab ");
- puts_filtered (ps->filename);
+ gdb_puts (ps->filename);
printf_filtered (" covers bad range ");
- puts_filtered (paddress (gdbarch, ps->text_low (objfile)));
+ gdb_puts (paddress (gdbarch, ps->text_low (objfile)));
printf_filtered (" - ");
- puts_filtered (paddress (gdbarch, ps->text_high (objfile)));
+ gdb_puts (paddress (gdbarch, ps->text_high (objfile)));
printf_filtered ("\n");
continue;
}
if (!sym)
{
printf_filtered ("Static symbol `");
- puts_filtered (psym->ginfo.linkage_name ());
+ gdb_puts (psym->ginfo.linkage_name ());
printf_filtered ("' only found in ");
- puts_filtered (ps->filename);
+ gdb_puts (ps->filename);
printf_filtered (" psymtab\n");
}
}
if (!sym)
{
printf_filtered ("Global symbol `");
- puts_filtered (psym->ginfo.linkage_name ());
+ gdb_puts (psym->ginfo.linkage_name ());
printf_filtered ("' only found in ");
- puts_filtered (ps->filename);
+ gdb_puts (ps->filename);
printf_filtered (" psymtab\n");
}
}
|| ps->text_high (objfile) > BLOCK_END (b)))
{
printf_filtered ("Psymtab ");
- puts_filtered (ps->filename);
+ gdb_puts (ps->filename);
printf_filtered (" covers ");
- puts_filtered (paddress (gdbarch, ps->text_low (objfile)));
+ gdb_puts (paddress (gdbarch, ps->text_low (objfile)));
printf_filtered (" - ");
- puts_filtered (paddress (gdbarch, ps->text_high (objfile)));
+ gdb_puts (paddress (gdbarch, ps->text_high (objfile)));
printf_filtered (" but symtab covers only ");
- puts_filtered (paddress (gdbarch, BLOCK_START (b)));
+ gdb_puts (paddress (gdbarch, BLOCK_START (b)));
printf_filtered (" - ");
- puts_filtered (paddress (gdbarch, BLOCK_END (b)));
+ gdb_puts (paddress (gdbarch, BLOCK_END (b)));
printf_filtered ("\n");
}
}
{
string_file stb;
- fputs_filtered (fa->sym->print_name (), &stb);
+ gdb_puts (fa->sym->print_name (), &stb);
if (fa->entry_kind == print_entry_values_compact)
{
stb.puts ("=");
- fputs_filtered (fa->sym->print_name (), &stb);
+ gdb_puts (fa->sym->print_name (), &stb);
}
if (fa->entry_kind == print_entry_values_only
|| fa->entry_kind == print_entry_values_compact)
language->printstr (stream, type, (gdb_byte *) output,
length, NULL, 0, options);
else
- fputs_filtered (output, stream);
+ gdb_puts (output, stream);
}
else
{
if (i == 0)
{
if (!is_py_none)
- fputs_filtered (" = ", stream);
+ gdb_puts (" = ", stream);
}
else if (! is_map || i % 2 == 0)
- fputs_filtered (pretty ? "," : ", ", stream);
+ gdb_puts (pretty ? "," : ", ", stream);
/* Skip printing children if max_depth has been reached. This check
is performed after print_string_repr and the "=" separator so that
return;
else if (i == 0)
/* Print initial "{" to bookend children. */
- fputs_filtered ("{", stream);
+ gdb_puts ("{", stream);
/* In summary mode, we just want to print "= {...}" if there is
a value. */
{
if (pretty)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
}
if (is_map && i % 2 == 0)
- fputs_filtered ("[", stream);
+ gdb_puts ("[", stream);
else if (is_array)
{
/* We print the index, not whatever the child method
}
else if (! is_map)
{
- fputs_filtered (name, stream);
- fputs_filtered (" = ", stream);
+ gdb_puts (name, stream);
+ gdb_puts (" = ", stream);
}
if (gdbpy_is_lazy_string (py_v))
if (!output)
gdbpy_print_stack ();
else
- fputs_filtered (output.get (), stream);
+ gdb_puts (output.get (), stream);
}
else
{
}
if (is_map && i % 2 == 0)
- fputs_filtered ("] = ", stream);
+ gdb_puts ("] = ", stream);
}
if (i)
{
if (pretty)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
- fputs_filtered ("...", stream);
+ gdb_puts ("...", stream);
}
if (pretty)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 * recurse, stream);
}
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
}
static void
dump_mem (const gdb_byte *buf, int len)
{
- fputs_unfiltered ("\t", gdb_stdlog);
+ gdb_puts ("\t", gdb_stdlog);
if (len == 8 || len == 4)
{
fprintf_unfiltered (gdb_stdlog, "0x%02x ", buf[i]);
}
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
}
/* Initialize gdb_callback. */
printf_filtered (_("Packets are limited to %ld bytes.\n"),
remote->get_memory_packet_size (config));
else
- puts_filtered ("The actual limit will be further reduced "
- "dependent on the target.\n");
+ gdb_puts ("The actual limit will be further reduced "
+ "dependent on the target.\n");
}
}
if (from_tty)
{
- puts_filtered ("Remote debugging using ");
- puts_filtered (name);
- puts_filtered ("\n");
+ gdb_puts ("Remote debugging using ");
+ gdb_puts (name);
+ gdb_puts ("\n");
}
/* Switch to using the remote target now. */
/* Exit only if this is the only active inferior. */
if (from_tty && !rs->extended && number_of_live_inferiors (this) == 1)
- puts_filtered (_("Ending remote debugging.\n"));
+ gdb_puts (_("Ending remote debugging.\n"));
/* See if any thread of the inferior we are detaching has a pending fork
status. In that case, we must detach from the child resulting from
remote_unpush_target (this);
if (from_tty)
- puts_filtered ("Ending remote debugging.\n");
+ gdb_puts ("Ending remote debugging.\n");
}
/* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
void sending (gdb::array_view<const char> &buf) override
{
- puts_filtered ("sending: ");
+ gdb_puts ("sending: ");
print_packet (buf);
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
/* Called with BUF, the reply from the remote target. */
void received (gdb::array_view<const char> &buf) override
{
- puts_filtered ("received: \"");
+ gdb_puts ("received: \"");
print_packet (buf);
- puts_filtered ("\"\n");
+ gdb_puts ("\"\n");
}
private:
fprintf_unfiltered (&stb, "\\x%02x", (unsigned char) c);
}
- puts_filtered (stb.string ().c_str ());
+ gdb_puts (stb.string ().c_str ());
}
};
int print_raw_format;
enum tab_stops { value_column_1 = 15 };
- fputs_filtered (name, file);
+ gdb_puts (name, file);
print_spaces_filtered (value_column_1 - strlen (name), file);
try
return;
if (type->name () != NULL)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
if (is_tuple || is_tuple_struct)
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
else
- fputs_filtered ("{", stream);
+ gdb_puts ("{", stream);
opts = *options;
opts.deref_ref = 0;
continue;
if (!first_field)
- fputs_filtered (",", stream);
+ gdb_puts (",", stream);
if (options->prettyformat)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
}
else if (!first_field)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
first_field = 0;
{
fputs_styled (type->field (i).name (),
variable_name_style.style (), stream);
- fputs_filtered (": ", stream);
+ gdb_puts (": ", stream);
}
common_val_print (value_field (val, i), stream, recurse + 1, &opts,
if (options->prettyformat)
{
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (2 * recurse, stream);
}
if (is_tuple || is_tuple_struct)
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
else
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
/* See rust-lang.h. */
for (int j = 0; j < variant_type->num_fields (); j++)
{
if (!first_field)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
first_field = false;
if (!is_tuple)
}
if (is_tuple)
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
else
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
static const struct generic_val_print_decorations rust_decorations =
if (opts.addressprint)
{
- fputs_filtered (paddress (arch, addr), stream);
- fputs_filtered (" ", stream);
+ gdb_puts (paddress (arch, addr), stream);
+ gdb_puts (" ", stream);
}
- fputs_filtered ("b", stream);
+ gdb_puts ("b", stream);
val_print_string (TYPE_TARGET_TYPE (elttype), "ASCII", addr,
high_bound - low_bound + 1, stream,
&opts);
if (type->is_unsigned () && TYPE_LENGTH (type) == 0
&& type->name () != NULL && strcmp (type->name (), "()") == 0)
{
- fputs_filtered ("()", stream);
+ gdb_puts ("()", stream);
break;
}
goto generic_print;
/* If we see a plain TYPE_CODE_STRING, then we're printing a
byte string, hence the choice of "ASCII" as the
encoding. */
- fputs_filtered ("b", stream);
+ gdb_puts ("b", stream);
printstr (stream, TYPE_TARGET_TYPE (type),
value_contents_for_printing (val).data (),
high_bound - low_bound + 1, "ASCII", 0, &opts);
if (get_array_bounds (type, &low_bound, &high_bound)
&& high_bound - low_bound + 1 == 0)
- fputs_filtered ("[]", stream);
+ gdb_puts ("[]", stream);
else
goto generic_print;
}
/* Print a tuple type simply. */
if (rust_tuple_type_p (type))
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
return;
}
/* This code path is also used by unions and enums. */
if (is_enum)
{
- fputs_filtered ("enum ", stream);
+ gdb_puts ("enum ", stream);
dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
if (prop != nullptr && prop->kind () == PROP_TYPE)
type = prop->original_type ();
}
else if (type->code () == TYPE_CODE_STRUCT)
- fputs_filtered ("struct ", stream);
+ gdb_puts ("struct ", stream);
else
- fputs_filtered ("union ", stream);
+ gdb_puts ("union ", stream);
if (tagname != NULL)
- fputs_filtered (tagname, stream);
+ gdb_puts (tagname, stream);
}
if (type->num_fields () == 0 && !is_tuple)
return;
if (for_rust_enum && !flags->print_offsets)
- fputs_filtered (is_tuple_struct ? "(" : "{", stream);
+ gdb_puts (is_tuple_struct ? "(" : "{", stream);
else
- fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
+ gdb_puts (is_tuple_struct ? " (\n" : " {\n", stream);
/* When printing offsets, we rearrange the fields into storage
order. This lets us show holes more clearly. We work using
stream, (is_enum ? show : show - 1),
level + 2, flags, is_enum, podata);
if (!for_rust_enum || flags->print_offsets)
- fputs_filtered (",\n", stream);
+ gdb_puts (",\n", stream);
/* Note that this check of "I" is ok because we only sorted the
fields by offset when print_offsets was set, so we won't take
this branch in that case. */
else if (i + 1 < type->num_fields ())
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
}
if (flags->print_offsets)
}
if (!for_rust_enum || flags->print_offsets)
print_spaces_filtered (level, stream);
- fputs_filtered (is_tuple_struct ? ")" : "}", stream);
+ gdb_puts (is_tuple_struct ? ")" : "}", stream);
}
/* la_print_type implementation for Rust. */
/* Rust calls the unit type "void" in its debuginfo,
but we don't want to print it as that. */
if (type->code () == TYPE_CODE_VOID)
- fputs_filtered ("()", stream);
+ gdb_puts ("()", stream);
else
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
return;
}
unqualified name, and there is nothing else to print
here. */
if (!for_rust_enum)
- fputs_filtered ("()", stream);
+ gdb_puts ("()", stream);
break;
case TYPE_CODE_FUNC:
if (type->has_varargs ())
goto c_printer;
- fputs_filtered ("fn ", stream);
+ gdb_puts ("fn ", stream);
if (varstring != NULL)
- fputs_filtered (varstring, stream);
- fputs_filtered ("(", stream);
+ gdb_puts (varstring, stream);
+ gdb_puts ("(", stream);
for (int i = 0; i < type->num_fields (); ++i)
{
QUIT;
if (i > 0)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
rust_internal_print_type (type->field (i).type (), "", stream,
-1, 0, flags, false, podata);
}
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
/* If it returns unit, we can omit the return type. */
if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
{
- fputs_filtered (" -> ", stream);
+ gdb_puts (" -> ", stream);
rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
-1, 0, flags, false, podata);
}
{
LONGEST low_bound, high_bound;
- fputs_filtered ("[", stream);
+ gdb_puts ("[", stream);
rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
stream, show - 1, level, flags, false,
podata);
else if (get_array_bounds (type, &low_bound, &high_bound))
fprintf_filtered (stream, "; %s",
plongest (high_bound - low_bound + 1));
- fputs_filtered ("]", stream);
+ gdb_puts ("]", stream);
}
break;
{
int len = 0;
- fputs_filtered ("enum ", stream);
+ gdb_puts ("enum ", stream);
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
- fputs_filtered (" ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (" ", stream);
len = strlen (type->name ());
}
- fputs_filtered ("{\n", stream);
+ gdb_puts ("{\n", stream);
for (int i = 0; i < type->num_fields (); ++i)
{
name));
}
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
break;
case TYPE_CODE_PTR:
{
if (type->name () != nullptr)
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
else
{
/* We currently can't distinguish between pointers and
references. */
- fputs_filtered ("*mut ", stream);
+ gdb_puts ("*mut ", stream);
type_print (TYPE_TARGET_TYPE (type), "", stream, 0);
}
}
else if (ch == '\\' || ch == quoter)
fprintf_filtered (stream, "\\%c", ch);
else if (ch == '\n')
- fputs_filtered ("\\n", stream);
+ gdb_puts ("\\n", stream);
else if (ch == '\r')
- fputs_filtered ("\\r", stream);
+ gdb_puts ("\\r", stream);
else if (ch == '\t')
- fputs_filtered ("\\t", stream);
+ gdb_puts ("\\t", stream);
else if (ch == '\0')
- fputs_filtered ("\\0", stream);
+ gdb_puts ("\\0", stream);
else if (ch >= 32 && ch <= 127 && isprint (ch))
fputc_filtered (ch, stream);
else if (ch <= 255)
void printchar (int ch, struct type *chtype,
struct ui_file *stream) const override
{
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
emitchar (ch, chtype, stream, '\'');
- fputs_filtered ("'", stream);
+ gdb_puts ("'", stream);
}
/* See language.h. */
struct value *v = value_of_register (reg, frame);
const char *name = gdbarch_register_name (gdbarch, reg);
uint32_t ccw = value_as_long (v);
- fputs_filtered (name, file);
+ gdb_puts (name, file);
size_t len = strlen (name);
const int stop_1 = 15;
const int stop_2 = 17;
while ((newline = strstr (current, "\n")) != NULL)
{
*newline = '\0';
- fputs_unfiltered (current, gdb_stderr);
- fputs_unfiltered ("\n", gdb_stderr);
+ gdb_puts (current, gdb_stderr);
+ gdb_puts ("\n", gdb_stderr);
current = newline + 1;
}
- fputs_unfiltered (current, gdb_stderr);
+ gdb_puts (current, gdb_stderr);
}
}
}
fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
return;
case SERIAL_EOF:
- fputs_unfiltered ("<Eof>", stream);
+ gdb_puts ("<Eof>", stream);
return;
case SERIAL_BREAK:
- fputs_unfiltered ("<Break>", stream);
+ gdb_puts ("<Break>", stream);
return;
default:
if (serial_logbase == logbase_hex)
switch (ch)
{
case '\\':
- fputs_unfiltered ("\\\\", stream);
+ gdb_puts ("\\\\", stream);
break;
case '\b':
- fputs_unfiltered ("\\b", stream);
+ gdb_puts ("\\b", stream);
break;
case '\f':
- fputs_unfiltered ("\\f", stream);
+ gdb_puts ("\\f", stream);
break;
case '\n':
- fputs_unfiltered ("\\n", stream);
+ gdb_puts ("\\n", stream);
break;
case '\r':
- fputs_unfiltered ("\\r", stream);
+ gdb_puts ("\\r", stream);
break;
case '\t':
- fputs_unfiltered ("\\t", stream);
+ gdb_puts ("\\t", stream);
break;
case '\v':
- fputs_unfiltered ("\\v", stream);
+ gdb_puts ("\\v", stream);
break;
default:
fprintf_unfiltered (stream,
serial_current_type = 'c';
- fputs_unfiltered ("\nc ", serial_logfp);
- fputs_unfiltered (cmd, serial_logfp);
+ gdb_puts ("\nc ", serial_logfp);
+ gdb_puts (cmd, serial_logfp);
/* Make sure that the log file is as up-to-date as possible,
in case we are getting ready to dump core or something. */
if (serial_logfp)
{
- fputs_unfiltered ("\nEnd of log\n", serial_logfp);
+ gdb_puts ("\nEnd of log\n", serial_logfp);
serial_current_type = 0;
/* XXX - What if serial_logfp == gdb_stdout or gdb_stderr? */
static void
show_directories_1 (ui_file *file, char *ignore, int from_tty)
{
- fputs_filtered ("Source directories searched: ", file);
- fputs_filtered (source_path.c_str (), file);
- fputs_filtered ("\n", file);
+ gdb_puts ("Source directories searched: ", file);
+ gdb_puts (source_path.c_str (), file);
+ gdb_puts ("\n", file);
}
/* Handler for "show directories" command. */
annotate_arg_emitter arg_emitter;
ui_out_emit_tuple tuple_emitter (uiout, NULL);
- fputs_filtered (arg->sym->print_name (), &stb);
+ gdb_puts (arg->sym->print_name (), &stb);
if (arg->entry_kind == print_entry_values_compact)
{
/* It is OK to provide invalid MI-like stream as with
PRINT_ENTRY_VALUE_COMPACT we never use MI. */
stb.puts ("=");
- fputs_filtered (arg->sym->print_name (), &stb);
+ gdb_puts (arg->sym->print_name (), &stb);
}
if (arg->entry_kind == print_entry_values_only
|| arg->entry_kind == print_entry_values_compact)
annotate_frame_function_name ();
string_file stb;
- fputs_filtered (funname ? funname.get () : "??", &stb);
+ gdb_puts (funname ? funname.get () : "??", &stb);
uiout->field_stream ("func", stb, function_name_style.style ());
uiout->wrap_hint (3);
annotate_frame_args ();
{
printf_filtered (_("Stack frame at "));
}
- puts_filtered (paddress (gdbarch, get_frame_base (fi)));
+ gdb_puts (paddress (gdbarch, get_frame_base (fi)));
printf_filtered (":\n");
printf_filtered (" %s = ", pc_regname);
if (frame_pc_p)
- puts_filtered (paddress (gdbarch, get_frame_pc (fi)));
+ gdb_puts (paddress (gdbarch, get_frame_pc (fi)));
else
fputs_styled ("<unavailable>", metadata_style.style (), gdb_stdout);
if (funname)
{
printf_filtered (" in ");
- puts_filtered (funname);
+ gdb_puts (funname);
}
gdb_stdout->wrap_here (3);
if (sal.symtab)
styled_string (file_name_style.style (),
symtab_to_filename_for_display (sal.symtab)),
sal.line);
- puts_filtered ("; ");
+ gdb_puts ("; ");
gdb_stdout->wrap_here (4);
printf_filtered ("saved %s = ", pc_regname);
}
if (caller_pc_p)
- puts_filtered (paddress (gdbarch, caller_pc));
+ gdb_puts (paddress (gdbarch, caller_pc));
printf_filtered ("\n");
if (calling_frame_info == NULL)
frame_stop_reason_string (fi));
}
else if (get_frame_type (fi) == TAILCALL_FRAME)
- puts_filtered (" tail call frame");
+ gdb_puts (" tail call frame");
else if (get_frame_type (fi) == INLINE_FRAME)
printf_filtered (" inlined into frame %d",
frame_relative_level (get_prev_frame (fi)));
else
{
printf_filtered (" called by frame at ");
- puts_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)));
+ gdb_puts (paddress (gdbarch, get_frame_base (calling_frame_info)));
}
if (get_next_frame (fi) && calling_frame_info)
- puts_filtered (",");
+ gdb_puts (",");
gdb_stdout->wrap_here (3);
if (get_next_frame (fi))
{
printf_filtered (" caller of frame at ");
- puts_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))));
+ gdb_puts (paddress (gdbarch, get_frame_base (get_next_frame (fi))));
}
if (get_next_frame (fi) || calling_frame_info)
- puts_filtered ("\n");
+ gdb_puts ("\n");
if (s)
printf_filtered (" source language %s.\n",
else
{
printf_filtered (" Arglist at ");
- puts_filtered (paddress (gdbarch, arg_list));
+ gdb_puts (paddress (gdbarch, arg_list));
printf_filtered (",");
if (!gdbarch_frame_num_args_p (gdbarch))
{
numargs = -1;
- puts_filtered (" args: ");
+ gdb_puts (" args: ");
}
else
{
numargs = gdbarch_frame_num_args (gdbarch, fi);
gdb_assert (numargs >= 0);
if (numargs == 0)
- puts_filtered (" no args.");
+ gdb_puts (" no args.");
else if (numargs == 1)
- puts_filtered (" 1 arg: ");
+ gdb_puts (" 1 arg: ");
else
printf_filtered (" %d args: ", numargs);
}
print_frame_args (user_frame_print_options,
func, fi, numargs, gdb_stdout);
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
}
{
else
{
printf_filtered (" Locals at ");
- puts_filtered (paddress (gdbarch, arg_list));
+ gdb_puts (paddress (gdbarch, arg_list));
printf_filtered (",");
}
}
(value_contents_all (value).data (), sp_size, byte_order);
printf_filtered (" Previous frame's sp is ");
- puts_filtered (paddress (gdbarch, sp));
+ gdb_puts (paddress (gdbarch, sp));
printf_filtered ("\n");
}
else if (VALUE_LVAL (value) == lval_memory)
{
printf_filtered (" Previous frame's sp at ");
- puts_filtered (paddress (gdbarch, value_address (value)));
+ gdb_puts (paddress (gdbarch, value_address (value)));
printf_filtered ("\n");
}
else if (VALUE_LVAL (value) == lval_register)
if (!optimized && !unavailable && lval == lval_memory)
{
if (count == 0)
- puts_filtered (" Saved registers:\n ");
+ gdb_puts (" Saved registers:\n ");
else
- puts_filtered (",");
+ gdb_puts (",");
gdb_stdout->wrap_here (1);
printf_filtered (" %s at ",
gdbarch_register_name (gdbarch, i));
- puts_filtered (paddress (gdbarch, addr));
+ gdb_puts (paddress (gdbarch, addr));
count++;
}
}
if (count || need_nl)
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
}
name = bfd_section_name (osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
- puts_filtered (paddress (gdbarch, lma));
- puts_filtered (" - ");
- puts_filtered (paddress (gdbarch, lma + size));
+ gdb_puts (paddress (gdbarch, lma));
+ gdb_puts (" - ");
+ gdb_puts (paddress (gdbarch, lma + size));
printf_filtered (", mapped at ");
- puts_filtered (paddress (gdbarch, vma));
- puts_filtered (" - ");
- puts_filtered (paddress (gdbarch, vma + size));
- puts_filtered ("\n");
+ gdb_puts (paddress (gdbarch, vma));
+ gdb_puts (" - ");
+ gdb_puts (paddress (gdbarch, vma + size));
+ gdb_puts ("\n");
nmapped++;
}
not try to respect copy relocations. */
CORE_ADDR addr = (msymbol->value.address
+ objfile->section_offsets[msymbol->section_index ()]);
- fputs_filtered (paddress (gdbarch, addr), outfile);
+ gdb_puts (paddress (gdbarch, addr), outfile);
fprintf_filtered (outfile, " %s", msymbol->linkage_name ());
if (section)
{
}
if (msymbol->filename)
fprintf_filtered (outfile, " %s", msymbol->filename);
- fputs_filtered ("\n", outfile);
+ gdb_puts ("\n", outfile);
index++;
}
if (objfile->per_bfd->minimal_symbol_count != index)
for (i = 0; i < len; i++)
{
fprintf_filtered (outfile, " line %d at ", l->item[i].line);
- fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
+ gdb_puts (paddress (gdbarch, l->item[i].pc), outfile);
if (l->item[i].is_stmt)
fprintf_filtered (outfile, "\t(stmt)");
fprintf_filtered (outfile, "\n");
wants it. */
fprintf_filtered (outfile, ", %d syms/buckets in ",
mdict_size (BLOCK_MULTIDICT (b)));
- fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
+ gdb_puts (paddress (gdbarch, BLOCK_START (b)), outfile);
fprintf_filtered (outfile, "..");
- fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
+ gdb_puts (paddress (gdbarch, BLOCK_END (b)), outfile);
if (BLOCK_FUNCTION (b))
{
fprintf_filtered (outfile, ", function %s",
if (symbol->domain () == LABEL_DOMAIN)
{
fprintf_filtered (outfile, "label %s at ", symbol->print_name ());
- fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
- outfile);
+ gdb_puts (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+ outfile);
if (section)
fprintf_filtered (outfile, " section %s\n",
bfd_section_name (section->the_bfd_section));
case LOC_STATIC:
fprintf_filtered (outfile, "static at ");
- fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
- outfile);
+ gdb_puts (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+ outfile);
if (section)
fprintf_filtered (outfile, " section %s",
bfd_section_name (section->the_bfd_section));
case LOC_LABEL:
fprintf_filtered (outfile, "label at ");
- fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
- outfile);
+ gdb_puts (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+ outfile);
if (section)
fprintf_filtered (outfile, " section %s",
bfd_section_name (section->the_bfd_section));
if (sym->line () != 0)
printf_filtered ("%d:\t", sym->line ());
else
- puts_filtered ("\t");
+ gdb_puts ("\t");
}
std::string str = symbol_to_info_string (sym, block, kind);
/* Helper macro. */
#define target_debug_do_print(E) \
- fputs_unfiltered ((E), gdb_stdlog);
+ gdb_puts ((E), gdb_stdlog);
#define target_debug_print_enum_target_object(X) \
target_debug_do_print (plongest (X))
static void
target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
{
- fputs_unfiltered (status->to_string ().c_str (), gdb_stdlog);
+ gdb_puts (status->to_string ().c_str (), gdb_stdlog);
}
\f
{
std::string str = target_options_to_string (options);
- fputs_unfiltered (str.c_str (), gdb_stdlog);
+ gdb_puts (str.c_str (), gdb_stdlog);
}
static void
target_debug_print_signals (gdb::array_view<const unsigned char> sigs)
{
- fputs_unfiltered ("{", gdb_stdlog);
+ gdb_puts ("{", gdb_stdlog);
for (size_t i = 0; i < sigs.size (); i++)
if (sigs[i] != 0)
fprintf_unfiltered (gdb_stdlog, " %s",
gdb_signal_to_name ((enum gdb_signal) i));
}
- fputs_unfiltered (" }", gdb_stdlog);
+ gdb_puts (" }", gdb_stdlog);
}
static void
static void
target_debug_print_const_gdb_byte_vector_r (const gdb::byte_vector &vector)
{
- fputs_unfiltered ("{", gdb_stdlog);
+ gdb_puts ("{", gdb_stdlog);
for (size_t i = 0; i < vector.size (); i++)
{
fprintf_unfiltered (gdb_stdlog, " %s",
phex_nz (vector[i], 1));
}
- fputs_unfiltered (" }", gdb_stdlog);
+ gdb_puts (" }", gdb_stdlog);
}
static void
this->beneath ()->post_attach (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->post_attach (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->detach (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->detach (", this->beneath ()->shortname ());
target_debug_print_inferior_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->disconnect (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->disconnect (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->resume (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->resume (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_step (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_gdb_signal (arg2);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->commit_resumed (...)\n", this->beneath ()->shortname ());
this->beneath ()->commit_resumed ();
fprintf_unfiltered (gdb_stdlog, "<- %s->commit_resumed (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
ptid_t
result = this->beneath ()->wait (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->wait (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_target_waitstatus_p (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_target_wait_flags (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_ptid_t (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->fetch_registers (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->fetch_registers (", this->beneath ()->shortname ());
target_debug_print_struct_regcache_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->store_registers (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->store_registers (", this->beneath ()->shortname ());
target_debug_print_struct_regcache_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->prepare_to_store (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->prepare_to_store (", this->beneath ()->shortname ());
target_debug_print_struct_regcache_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->files_info (...)\n", this->beneath ()->shortname ());
this->beneath ()->files_info ();
fprintf_unfiltered (gdb_stdlog, "<- %s->files_info (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
result = this->beneath ()->insert_breakpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_breakpoint (", this->beneath ()->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_breakpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_breakpoint (", this->beneath ()->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_remove_bp_reason (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_by_sw_breakpoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->stopped_by_sw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_by_sw_breakpoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_stopped_by_sw_breakpoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_stopped_by_sw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_stopped_by_sw_breakpoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_by_hw_breakpoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->stopped_by_hw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_by_hw_breakpoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_stopped_by_hw_breakpoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_stopped_by_hw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_stopped_by_hw_breakpoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->can_use_hw_breakpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->can_use_hw_breakpoint (", this->beneath ()->shortname ());
target_debug_print_enum_bptype (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->ranged_break_num_registers (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->ranged_break_num_registers ();
fprintf_unfiltered (gdb_stdlog, "<- %s->ranged_break_num_registers (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->insert_hw_breakpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_hw_breakpoint (", this->beneath ()->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_hw_breakpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_hw_breakpoint (", this->beneath ()->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_watchpoint (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_watchpoint (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->insert_watchpoint (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_watchpoint (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->insert_mask_watchpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_mask_watchpoint (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_mask_watchpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_mask_watchpoint (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_by_watchpoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->stopped_by_watchpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_by_watchpoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->have_steppable_watchpoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->have_steppable_watchpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->have_steppable_watchpoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->stopped_data_address (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_data_address (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->watchpoint_addr_within_range (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->watchpoint_addr_within_range (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->region_ok_for_hw_watchpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->region_ok_for_hw_watchpoint (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->can_accel_watchpoint_condition (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->can_accel_watchpoint_condition (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->masked_watch_num_registers (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->masked_watch_num_registers (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->can_do_single_step (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->can_do_single_step ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_do_single_step (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_terminal_ours (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_terminal_ours ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_terminal_ours (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_init (...)\n", this->beneath ()->shortname ());
this->beneath ()->terminal_init ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_init (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_inferior (...)\n", this->beneath ()->shortname ());
this->beneath ()->terminal_inferior ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_inferior (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_save_inferior (...)\n", this->beneath ()->shortname ());
this->beneath ()->terminal_save_inferior ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_save_inferior (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_ours_for_output (...)\n", this->beneath ()->shortname ());
this->beneath ()->terminal_ours_for_output ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_ours_for_output (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_ours (...)\n", this->beneath ()->shortname ());
this->beneath ()->terminal_ours ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_ours (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->terminal_info (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_info (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->kill (...)\n", this->beneath ()->shortname ());
this->beneath ()->kill ();
fprintf_unfiltered (gdb_stdlog, "<- %s->kill (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->load (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->load (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
result = this->beneath ()->insert_fork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_fork_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_fork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_fork_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->insert_vfork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_vfork_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_vfork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_vfork_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->follow_fork (arg0, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->follow_fork (", this->beneath ()->shortname ());
target_debug_print_inferior_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ptid_t (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_target_waitkind (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_bool (arg3);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_bool (arg4);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
result = this->beneath ()->insert_exec_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_exec_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->remove_exec_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_exec_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->follow_exec (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->follow_exec (", this->beneath ()->shortname ());
target_debug_print_inferior_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ptid_t (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_char_p (arg2);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
result = this->beneath ()->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_syscall_catchpoint (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_bool (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_array_view_const_int (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->mourn_inferior (...)\n", this->beneath ()->shortname ());
this->beneath ()->mourn_inferior ();
fprintf_unfiltered (gdb_stdlog, "<- %s->mourn_inferior (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->pass_signals (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->pass_signals (", this->beneath ()->shortname ());
target_debug_print_signals (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->program_signals (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->program_signals (", this->beneath ()->shortname ());
target_debug_print_signals (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
result = this->beneath ()->thread_alive (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_alive (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->update_thread_list (...)\n", this->beneath ()->shortname ());
this->beneath ()->update_thread_list ();
fprintf_unfiltered (gdb_stdlog, "<- %s->update_thread_list (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
std::string
result = this->beneath ()->pid_to_str (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->pid_to_str (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_std_string (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->extra_thread_info (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->extra_thread_info (", this->beneath ()->shortname ());
target_debug_print_thread_info_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_char_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->thread_name (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_name (", this->beneath ()->shortname ());
target_debug_print_thread_info_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_char_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->thread_handle_to_thread_info (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_handle_to_thread_info (", this->beneath ()->shortname ());
target_debug_print_const_gdb_byte_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_inferior_p (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_thread_info_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->thread_info_to_thread_handle (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_info_to_thread_handle (", this->beneath ()->shortname ());
target_debug_print_struct_thread_info_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_gdb_byte_vector (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->stop (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->stop (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->interrupt (...)\n", this->beneath ()->shortname ());
this->beneath ()->interrupt ();
fprintf_unfiltered (gdb_stdlog, "<- %s->interrupt (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->pass_ctrlc (...)\n", this->beneath ()->shortname ());
this->beneath ()->pass_ctrlc ();
fprintf_unfiltered (gdb_stdlog, "<- %s->pass_ctrlc (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->rcmd (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->rcmd (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_ui_file_p (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
char *
result = this->beneath ()->pid_to_exec_file (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->pid_to_exec_file (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_char_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->log_command (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->log_command (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
const target_section_table *
fprintf_unfiltered (gdb_stdlog, "-> %s->get_section_table (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->get_section_table ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_section_table (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_target_section_table_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->get_thread_control_capabilities (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->get_thread_control_capabilities ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_thread_control_capabilities (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_thread_control_capabilities (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->attach_no_wait (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->attach_no_wait ();
fprintf_unfiltered (gdb_stdlog, "<- %s->attach_no_wait (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->can_async_p (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->can_async_p ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_async_p (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->is_async_p (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->is_async_p ();
fprintf_unfiltered (gdb_stdlog, "<- %s->is_async_p (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->async (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->async (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
fprintf_unfiltered (gdb_stdlog, "-> %s->async_wait_fd (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->async_wait_fd ();
fprintf_unfiltered (gdb_stdlog, "<- %s->async_wait_fd (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->has_pending_events (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->has_pending_events ();
fprintf_unfiltered (gdb_stdlog, "<- %s->has_pending_events (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->thread_events (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_events (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_non_stop (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_non_stop ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_non_stop (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->always_non_stop_p (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->always_non_stop_p ();
fprintf_unfiltered (gdb_stdlog, "<- %s->always_non_stop_p (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->find_memory_regions (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->find_memory_regions (", this->beneath ()->shortname ());
target_debug_print_find_memory_region_ftype (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_void_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->make_corefile_notes (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->make_corefile_notes (", this->beneath ()->shortname ());
target_debug_print_bfd_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_gdb_unique_xmalloc_ptr_char (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->get_bookmark (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_bookmark (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_gdb_byte_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->goto_bookmark (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_bookmark (", this->beneath ()->shortname ());
target_debug_print_const_gdb_byte_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
CORE_ADDR
result = this->beneath ()->get_thread_local_address (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_thread_local_address (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_CORE_ADDR (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
fprintf_unfiltered (gdb_stdlog, "<- %s->xfer_partial (", this->beneath ()->shortname ());
target_debug_print_enum_target_object (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_byte_p (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_p (arg3);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg4);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg5);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST_p (arg6);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_enum_target_xfer_status (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->get_memory_xfer_limit (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->get_memory_xfer_limit ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_memory_xfer_limit (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_ULONGEST (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->memory_map (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->memory_map ();
fprintf_unfiltered (gdb_stdlog, "<- %s->memory_map (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_std_vector_mem_region (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->flash_erase (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->flash_erase (", this->beneath ()->shortname ());
target_debug_print_ULONGEST (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_LONGEST (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->flash_done (...)\n", this->beneath ()->shortname ());
this->beneath ()->flash_done ();
fprintf_unfiltered (gdb_stdlog, "<- %s->flash_done (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
const struct target_desc *
fprintf_unfiltered (gdb_stdlog, "-> %s->read_description (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->read_description ();
fprintf_unfiltered (gdb_stdlog, "<- %s->read_description (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_struct_target_desc_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->get_ada_task_ptid (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_ada_task_ptid (", this->beneath ()->shortname ());
target_debug_print_long (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_ptid_t (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->auxv_parse (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->auxv_parse (", this->beneath ()->shortname ());
target_debug_print_gdb_byte_pp (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_byte_p (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->search_memory (arg0, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->search_memory (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_p (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg3);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg4);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->can_execute_reverse (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->can_execute_reverse ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_execute_reverse (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->execution_direction (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->execution_direction ();
fprintf_unfiltered (gdb_stdlog, "<- %s->execution_direction (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_enum_exec_direction_kind (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_multi_process (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_multi_process ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_multi_process (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_enable_disable_tracepoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_enable_disable_tracepoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_enable_disable_tracepoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_disable_randomization (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_disable_randomization ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_disable_randomization (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_string_tracing (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_string_tracing ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_string_tracing (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_evaluation_of_breakpoint_conditions (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_evaluation_of_breakpoint_conditions ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_evaluation_of_breakpoint_conditions (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_dumpcore (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_dumpcore ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_dumpcore (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->dumpcore (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->dumpcore (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
fprintf_unfiltered (gdb_stdlog, "-> %s->can_run_breakpoint_commands (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->can_run_breakpoint_commands ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_run_breakpoint_commands (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->thread_architecture (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_architecture (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_struct_gdbarch_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->thread_address_space (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_address_space (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_struct_address_space_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->filesystem_is_local (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->filesystem_is_local ();
fprintf_unfiltered (gdb_stdlog, "<- %s->filesystem_is_local (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_init (...)\n", this->beneath ()->shortname ());
this->beneath ()->trace_init ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_init (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->download_tracepoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->download_tracepoint (", this->beneath ()->shortname ());
target_debug_print_struct_bp_location_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
fprintf_unfiltered (gdb_stdlog, "-> %s->can_download_tracepoint (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->can_download_tracepoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_download_tracepoint (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->download_trace_state_variable (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->download_trace_state_variable (", this->beneath ()->shortname ());
target_debug_print_const_trace_state_variable_r (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->enable_tracepoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->enable_tracepoint (", this->beneath ()->shortname ());
target_debug_print_struct_bp_location_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->disable_tracepoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->disable_tracepoint (", this->beneath ()->shortname ());
target_debug_print_struct_bp_location_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_set_readonly_regions (...)\n", this->beneath ()->shortname ());
this->beneath ()->trace_set_readonly_regions ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_set_readonly_regions (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_start (...)\n", this->beneath ()->shortname ());
this->beneath ()->trace_start ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_start (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
result = this->beneath ()->get_trace_status (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_trace_status (", this->beneath ()->shortname ());
target_debug_print_struct_trace_status_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->get_tracepoint_status (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_tracepoint_status (", this->beneath ()->shortname ());
target_debug_print_struct_breakpoint_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_uploaded_tp_p (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_stop (...)\n", this->beneath ()->shortname ());
this->beneath ()->trace_stop ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_stop (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
int
result = this->beneath ()->trace_find (arg0, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_find (", this->beneath ()->shortname ());
target_debug_print_enum_trace_find_type (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg3);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int_p (arg4);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->get_trace_state_variable_value (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_trace_state_variable_value (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_LONGEST_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->save_trace_data (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->save_trace_data (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->upload_tracepoints (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->upload_tracepoints (", this->beneath ()->shortname ());
target_debug_print_struct_uploaded_tp_pp (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->upload_trace_state_variables (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->upload_trace_state_variables (", this->beneath ()->shortname ());
target_debug_print_struct_uploaded_tsv_pp (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->get_raw_trace_data (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_raw_trace_data (", this->beneath ()->shortname ());
target_debug_print_gdb_byte_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_LONGEST (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_LONGEST (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->get_min_fast_tracepoint_insn_len (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->get_min_fast_tracepoint_insn_len ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_min_fast_tracepoint_insn_len (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->set_disconnected_tracing (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_disconnected_tracing (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->set_circular_trace_buffer (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_circular_trace_buffer (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->set_trace_buffer_size (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_trace_buffer_size (", this->beneath ()->shortname ());
target_debug_print_LONGEST (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
result = this->beneath ()->set_trace_notes (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_trace_notes (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_char_p (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->core_of_thread (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->core_of_thread (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->verify_memory (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->verify_memory (", this->beneath ()->shortname ());
target_debug_print_const_gdb_byte_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->get_tib_address (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_tib_address (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->set_permissions (...)\n", this->beneath ()->shortname ());
this->beneath ()->set_permissions ();
fprintf_unfiltered (gdb_stdlog, "<- %s->set_permissions (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
result = this->beneath ()->static_tracepoint_marker_at (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->static_tracepoint_marker_at (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_static_tracepoint_marker_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->static_tracepoint_markers_by_strid (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->static_tracepoint_markers_by_strid (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_std_vector_static_tracepoint_marker (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->traceframe_info (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->traceframe_info ();
fprintf_unfiltered (gdb_stdlog, "<- %s->traceframe_info (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_traceframe_info_up (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->use_agent (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->use_agent (", this->beneath ()->shortname ());
target_debug_print_bool (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->can_use_agent (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->can_use_agent ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_use_agent (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->enable_btrace (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->enable_btrace (", this->beneath ()->shortname ());
target_debug_print_thread_info_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_struct_btrace_config_p (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_struct_btrace_target_info_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
this->beneath ()->disable_btrace (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->disable_btrace (", this->beneath ()->shortname ());
target_debug_print_struct_btrace_target_info_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->teardown_btrace (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->teardown_btrace (", this->beneath ()->shortname ());
target_debug_print_struct_btrace_target_info_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
enum btrace_error
result = this->beneath ()->read_btrace (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->read_btrace (", this->beneath ()->shortname ());
target_debug_print_struct_btrace_data_p (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_struct_btrace_target_info_p (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_enum_btrace_read_type (arg2);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_enum_btrace_error (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->btrace_conf (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->btrace_conf (", this->beneath ()->shortname ());
target_debug_print_const_struct_btrace_target_info_p (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_struct_btrace_config_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->record_method (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->record_method (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_enum_record_method (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->stop_recording (...)\n", this->beneath ()->shortname ());
this->beneath ()->stop_recording ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stop_recording (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->info_record (...)\n", this->beneath ()->shortname ());
this->beneath ()->info_record ();
fprintf_unfiltered (gdb_stdlog, "<- %s->info_record (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->save_record (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->save_record (", this->beneath ()->shortname ());
target_debug_print_const_char_p (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_delete_record (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_delete_record ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_delete_record (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->delete_record (...)\n", this->beneath ()->shortname ());
this->beneath ()->delete_record ();
fprintf_unfiltered (gdb_stdlog, "<- %s->delete_record (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
result = this->beneath ()->record_is_replaying (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->record_is_replaying (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->record_will_replay (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->record_will_replay (", this->beneath ()->shortname ());
target_debug_print_ptid_t (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->record_stop_replaying (...)\n", this->beneath ()->shortname ());
this->beneath ()->record_stop_replaying ();
fprintf_unfiltered (gdb_stdlog, "<- %s->record_stop_replaying (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record_begin (...)\n", this->beneath ()->shortname ());
this->beneath ()->goto_record_begin ();
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record_begin (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record_end (...)\n", this->beneath ()->shortname ());
this->beneath ()->goto_record_end ();
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record_end (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->goto_record (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record (", this->beneath ()->shortname ());
target_debug_print_ULONGEST (arg0);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->insn_history (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_disassembly_flags (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->insn_history_from (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history_from (", this->beneath ()->shortname ());
target_debug_print_ULONGEST (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_disassembly_flags (arg2);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->insn_history_range (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history_range (", this->beneath ()->shortname ());
target_debug_print_ULONGEST (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_disassembly_flags (arg2);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->call_history (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->call_history (", this->beneath ()->shortname ());
target_debug_print_int (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_record_print_flags (arg1);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->call_history_from (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->call_history_from (", this->beneath ()->shortname ());
target_debug_print_ULONGEST (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_record_print_flags (arg2);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
this->beneath ()->call_history_range (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->call_history_range (", this->beneath ()->shortname ());
target_debug_print_ULONGEST (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_record_print_flags (arg2);
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
fprintf_unfiltered (gdb_stdlog, "-> %s->augmented_libraries_svr4_read (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->augmented_libraries_svr4_read ();
fprintf_unfiltered (gdb_stdlog, "<- %s->augmented_libraries_svr4_read (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->get_unwinder (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->get_unwinder ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_unwinder (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_struct_frame_unwind_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->get_tailcall_unwinder (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->get_tailcall_unwinder ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_tailcall_unwinder (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_const_struct_frame_unwind_p (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
fprintf_unfiltered (gdb_stdlog, "-> %s->prepare_to_generate_core (...)\n", this->beneath ()->shortname ());
this->beneath ()->prepare_to_generate_core ();
fprintf_unfiltered (gdb_stdlog, "<- %s->prepare_to_generate_core (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
void
fprintf_unfiltered (gdb_stdlog, "-> %s->done_generating_core (...)\n", this->beneath ()->shortname ());
this->beneath ()->done_generating_core ();
fprintf_unfiltered (gdb_stdlog, "<- %s->done_generating_core (", this->beneath ()->shortname ());
- fputs_unfiltered (")\n", gdb_stdlog);
+ gdb_puts (")\n", gdb_stdlog);
}
bool
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_memory_tagging (...)\n", this->beneath ()->shortname ());
result = this->beneath ()->supports_memory_tagging ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_memory_tagging (", this->beneath ()->shortname ());
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->fetch_memtags (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->fetch_memtags (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_size_t (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_gdb_byte_vector_r (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
result = this->beneath ()->store_memtags (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->store_memtags (", this->beneath ()->shortname ());
target_debug_print_CORE_ADDR (arg0);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_size_t (arg1);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_vector_r (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
+ gdb_puts (", ", gdb_stdlog);
target_debug_print_int (arg3);
- fputs_unfiltered (") = ", gdb_stdlog);
+ gdb_puts (") = ", gdb_stdlog);
target_debug_print_bool (result);
- fputs_unfiltered ("\n", gdb_stdlog);
+ gdb_puts ("\n", gdb_stdlog);
return result;
}
std::string buf;
print_xml_feature v (&buf);
tdesc->accept (v);
- puts_filtered (buf.c_str ());
+ gdb_puts (buf.c_str ());
}
namespace selftests {
{
int i;
- fputs_unfiltered (", bytes =", gdb_stdlog);
+ gdb_puts (", bytes =", gdb_stdlog);
for (i = 0; i < *xfered_len; i++)
{
if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
void
tui_layout_window::specification (ui_file *output, int depth)
{
- fputs_unfiltered (get_name (), output);
+ gdb_puts (get_name (), output);
}
/* See tui-layout.h. */
tui_layout_split::specification (ui_file *output, int depth)
{
if (depth > 0)
- fputs_unfiltered ("{", output);
+ gdb_puts ("{", output);
if (!m_vertical)
- fputs_unfiltered ("-horizontal ", output);
+ gdb_puts ("-horizontal ", output);
bool first = true;
for (auto &item : m_splits)
{
if (!first)
- fputs_unfiltered (" ", output);
+ gdb_puts (" ", output);
first = false;
item.layout->specification (output, depth + 1);
fprintf_unfiltered (output, " %d", item.weight);
}
if (depth > 0)
- fputs_unfiltered ("}", output);
+ gdb_puts ("}", output);
}
/* Destroy the layout associated with SELF. */
{
fprintf_styled (stream, highlight_style.style (),
"/* XXX %2u-bit %-7s */", hole_bit, for_what);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
}
if (hole_byte > 0)
{
fprintf_styled (stream, highlight_style.style (),
"/* XXX %2u-byte %-7s */", hole_byte, for_what);
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
}
}
}
unsigned int bitpos = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
maybe_print_hole (stream, bitpos, "padding");
- fputs_filtered ("\n", stream);
+ gdb_puts ("\n", stream);
print_spaces_filtered (level + 4 + print_offset_data::indentation, stream);
fprintf_filtered (stream, "/* total size (bytes): %4s */\n",
pulongest (TYPE_LENGTH (type)));
}
if (i < len)
{
- fputs_filtered (type->field (i).name (), stream);
+ gdb_puts (type->field (i).name (), stream);
}
else
{
gdb_stdout->wrap_here (0); /* Force out any buffered output. */
gdb_flush (gdb_stdout);
if (warning_pre_print)
- fputs_unfiltered (warning_pre_print, gdb_stderr);
+ gdb_puts (warning_pre_print, gdb_stderr);
gdb_vprintf (gdb_stderr, string, args);
fprintf_unfiltered (gdb_stderr, "\n");
}
if (current_ui == NULL)
fputs (msg, stderr);
else
- fputs_unfiltered (msg, gdb_stderr);
+ gdb_puts (msg, gdb_stderr);
abort (); /* ARI: abort */
}
else
internal_error (__FILE__, __LINE__, _("bad switch"));
- fputs_unfiltered (_("\nThis is a bug, please report it."), gdb_stderr);
+ gdb_puts (_("\nThis is a bug, please report it."), gdb_stderr);
if (REPORT_BUGS_TO[0])
fprintf_unfiltered (gdb_stderr, _(" For instructions, see:\n%s."),
REPORT_BUGS_TO);
- fputs_unfiltered ("\n\n", gdb_stderr);
+ gdb_puts ("\n\n", gdb_stderr);
if (problem->should_dump_core == internal_problem_ask)
{
/* Buffer and start column of buffered text, for doing smarter word-
wrapping. When someone calls wrap_here(), we start buffering output
- that comes through fputs_filtered(). If we see a newline, we just
+ that comes through gdb_puts(). If we see a newline, we just
spit it out and forget about the wrap_here(). If we see another
wrap_here(), we spit it out and remember the newer one. If we see
the end of the line, we spit out a newline, the indent, and then
gdb_assert (chars_per_line > 0);
if (chars_per_line == UINT_MAX)
{
- puts_filtered (string);
- puts_filtered ("\n");
+ gdb_puts (string);
+ gdb_puts ("\n");
return;
}
if (((chars_printed - 1) / width + 2) * width >= chars_per_line)
- puts_filtered ("\n");
+ gdb_puts ("\n");
if (width >= chars_per_line)
width = chars_per_line - 1;
while (spaces--)
spacebuf[spaces] = ' ';
- puts_filtered (spacebuf);
- puts_filtered (string);
+ gdb_puts (spacebuf);
+ gdb_puts (string);
}
{
if (chars_printed > 0)
{
- puts_filtered ("\n");
+ gdb_puts ("\n");
}
}
}
void
-fputs_unfiltered (const char *linebuffer, struct ui_file *stream)
-{
- stream->puts_unfiltered (linebuffer);
-}
-
-void
-fputs_filtered (const char *linebuffer, struct ui_file *stream)
+gdb_puts (const char *linebuffer, struct ui_file *stream)
{
stream->puts (linebuffer);
}
struct ui_file *stream)
{
stream->emit_style_escape (style);
- fputs_filtered (linebuffer, stream);
+ gdb_puts (linebuffer, stream);
stream->emit_style_escape (ui_file_style ());
}
/* Output the trailing part of STR not matching HIGHLIGHT. */
if (*str)
- fputs_filtered (str, stream);
+ gdb_puts (str, stream);
}
/* Write character C to gdb_stdout using GDB's paging mechanism and return C.
buf[0] = c;
buf[1] = 0;
- fputs_unfiltered (buf, stream);
+ gdb_puts (buf, stream);
return c;
}
buf[0] = c;
buf[1] = 0;
- fputs_filtered (buf, stream);
+ gdb_puts (buf, stream);
return c;
}
This one doesn't, and had better not! */
void
-puts_filtered (const char *string)
+gdb_puts (const char *string)
{
- fputs_filtered (string, gdb_stdout);
+ gdb_stdout->puts (string);
}
/* Return a pointer to N spaces and a null. The pointer is good
void
print_spaces_filtered (int n, struct ui_file *stream)
{
- fputs_filtered (n_spaces (n), stream);
+ gdb_puts (n_spaces (n), stream);
}
\f
/* C++/ObjC demangler stuff. */
/* If user wants to see raw output, no problem. */
if (!demangle)
{
- fputs_filtered (name, stream);
+ gdb_puts (name, stream);
}
else
{
gdb::unique_xmalloc_ptr<char> demangled
= language_demangle (language_def (lang), name, arg_mode);
- fputs_filtered (demangled ? demangled.get () : name, stream);
+ gdb_puts (demangled ? demangled.get () : name, stream);
}
}
}
here are the styling formatters: '%p[', '%p]' and '%ps'. See
ui_out::message for details. */
-extern void fputs_filtered (const char *, struct ui_file *);
-
-extern void fputs_unfiltered (const char *, struct ui_file *);
+extern void gdb_puts (const char *, struct ui_file *);
extern int fputc_filtered (int c, struct ui_file *);
extern int putchar_filtered (int c);
-extern void puts_filtered (const char *);
+extern void gdb_puts (const char *);
extern void puts_filtered_tabular (char *string, int width, int right);
va_list args)
ATTRIBUTE_PRINTF (3, 0);
-/* Like fputs_filtered, but styles the output according to STYLE, when
+/* Like gdb_puts, but styles the output according to STYLE, when
appropriate. */
extern void fputs_styled (const char *linebuffer,
if (options->symbol_print)
print_address_demangle (options, gdbarch, address, stream, demangle);
else if (options->addressprint)
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_puts (paddress (gdbarch, address), stream);
}
/* generic_val_print helper for TYPE_CODE_ARRAY. */
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
- fputs_filtered (decorations->array_start, stream);
+ gdb_puts (decorations->array_start, stream);
value_print_array_elements (val, stream, recurse, options, 0);
- fputs_filtered (decorations->array_end, stream);
+ gdb_puts (decorations->array_end, stream);
}
else
{
= extract_typed_address (address_buffer + embedded_offset, type);
fprintf_filtered (stream, "@");
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_puts (paddress (gdbarch, address), stream);
}
/* Else: we have a non-addressable value, such as a DW_AT_const_value. */
}
print_ref_address (type, address, embedded_offset, stream);
if (options->deref_ref)
- fputs_filtered (": ", stream);
+ gdb_puts (": ", stream);
}
if (options->deref_ref)
common_val_print (deref_val, stream, recurse, options,
current_language);
else
- fputs_filtered ("???", stream);
+ gdb_puts ("???", stream);
}
}
{
if (first)
{
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
first = 0;
}
else
- fputs_filtered (" | ", stream);
+ gdb_puts (" | ", stream);
val &= ~type->field (i).loc_enumval ();
fputs_styled (type->field (i).name (),
{
/* There are leftover bits, print them. */
if (first)
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
else
- fputs_filtered (" | ", stream);
+ gdb_puts (" | ", stream);
- fputs_filtered ("unknown: 0x", stream);
+ gdb_puts ("unknown: 0x", stream);
print_longest (stream, 'x', 0, val);
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
else if (first)
{
/* Nothing has been printed and the value is 0, the enum value must
have been 0. */
- fputs_filtered ("0", stream);
+ gdb_puts ("0", stream);
}
else
{
/* Something has been printed, close the parenthesis. */
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
}
else
struct type *type = check_typedef (value_type (value));
LONGEST val = unpack_long (type, valaddr);
if (val == 0)
- fputs_filtered (decorations->false_name, stream);
+ gdb_puts (decorations->false_name, stream);
else if (val == 1)
- fputs_filtered (decorations->true_name, stream);
+ gdb_puts (decorations->true_name, stream);
else
print_longest (stream, 'd', 0, val);
}
fprintf_filtered (stream, "%u", (unsigned int) val);
else
fprintf_filtered (stream, "%d", (int) val);
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
current_language->printchar (val, unresolved_type, stream);
}
}
break;
case TYPE_CODE_VOID:
- fputs_filtered (decorations->void_name, stream);
+ gdb_puts (decorations->void_name, stream);
break;
case TYPE_CODE_ERROR:
if (options->max_depth > -1 && recurse >= options->max_depth)
{
gdb_assert (language->struct_too_deep_ellipsis () != NULL);
- fputs_filtered (language->struct_too_deep_ellipsis (), stream);
+ gdb_puts (language->struct_too_deep_ellipsis (), stream);
return true;
}
struct gdbarch *gdbarch = type->arch ();
struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
- fputs_filtered ("[", stream);
+ gdb_puts ("[", stream);
for (field = 0; field < nfields; field++)
{
if (type->field (field).name ()[0] != '\0')
}
}
}
- fputs_filtered (" ]", stream);
+ gdb_puts (" ]", stream);
}
/* See valprint.h. */
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
}
- fputs_filtered (val, stream);
+ gdb_puts (val, stream);
}
/* This used to be a macro, but I don't think it is called often enough
struct ui_file *stream)
{
std::string str = target_float_to_string (valaddr, type);
- fputs_filtered (str.c_str (), stream);
+ gdb_puts (str.c_str (), stream);
}
void
cycle = (len * HOST_CHAR_BIT) % BITS_IN_OCTAL;
carry = 0;
- fputs_filtered ("0", stream);
+ gdb_puts ("0", stream);
bool seen_a_one = false;
if (byte_order == BFD_ENDIAN_BIG)
{
if (is_signed
&& maybe_negate_by_bytes (valaddr, len, byte_order, &negated_bytes))
{
- fputs_filtered ("-", stream);
+ gdb_puts ("-", stream);
valaddr = negated_bytes.data ();
}
{
const gdb_byte *p;
- fputs_filtered ("0x", stream);
+ gdb_puts ("0x", stream);
if (byte_order == BFD_ENDIAN_BIG)
{
p = valaddr;
the address of the description. */
if (options->addressprint && func_addr != address)
{
- fputs_filtered ("@", stream);
- fputs_filtered (paddress (gdbarch, address), stream);
- fputs_filtered (": ", stream);
+ gdb_puts ("@", stream);
+ gdb_puts (paddress (gdbarch, address), stream);
+ gdb_puts (": ", stream);
}
print_address_demangle (options, gdbarch, func_addr, stream, demangle);
}
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered ((const char *) obstack_base (&output), stream);
+ gdb_puts ((const char *) obstack_base (&output), stream);
}
/* Return the repeat count of the next character/byte in ITER,
if (length == 0)
{
- fputs_filtered ("\"\"", stream);
+ gdb_puts ("\"\"", stream);
return;
}
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered ((const char *) obstack_base (&output), stream);
+ gdb_puts ((const char *) obstack_base (&output), stream);
}
/* Print a string from the inferior, starting at ADDR and printing up to LEN
printf_filtered ("0x%03x: ", (unsigned) sel);
if (!info.HighWord.Bits.Pres)
{
- puts_filtered ("Segment not present\n");
+ gdb_puts ("Segment not present\n");
return 0;
}
base = (info.HighWord.Bits.BaseHi << 24) +
limit = (limit << 12) | 0xfff;
printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
if (info.HighWord.Bits.Default_Big)
- puts_filtered(" 32-bit ");
+ gdb_puts(" 32-bit ");
else
- puts_filtered(" 16-bit ");
+ gdb_puts(" 16-bit ");
switch ((info.HighWord.Bits.Type & 0xf) >> 1)
{
case 0:
- puts_filtered ("Data (Read-Only, Exp-up");
+ gdb_puts ("Data (Read-Only, Exp-up");
break;
case 1:
- puts_filtered ("Data (Read/Write, Exp-up");
+ gdb_puts ("Data (Read/Write, Exp-up");
break;
case 2:
- puts_filtered ("Unused segment (");
+ gdb_puts ("Unused segment (");
break;
case 3:
- puts_filtered ("Data (Read/Write, Exp-down");
+ gdb_puts ("Data (Read/Write, Exp-down");
break;
case 4:
- puts_filtered ("Code (Exec-Only, N.Conf");
+ gdb_puts ("Code (Exec-Only, N.Conf");
break;
case 5:
- puts_filtered ("Code (Exec/Read, N.Conf");
+ gdb_puts ("Code (Exec/Read, N.Conf");
break;
case 6:
- puts_filtered ("Code (Exec-Only, Conf");
+ gdb_puts ("Code (Exec-Only, Conf");
break;
case 7:
- puts_filtered ("Code (Exec/Read, Conf");
+ gdb_puts ("Code (Exec/Read, Conf");
break;
default:
printf_filtered ("Unknown type 0x%lx",
(unsigned long) info.HighWord.Bits.Type);
}
if ((info.HighWord.Bits.Type & 0x1) == 0)
- puts_filtered(", N.Acc");
- puts_filtered (")\n");
+ gdb_puts(", N.Acc");
+ gdb_puts (")\n");
if ((info.HighWord.Bits.Type & 0x10) == 0)
- puts_filtered("System selector ");
+ gdb_puts("System selector ");
printf_filtered ("Priviledge level = %ld. ",
(unsigned long) info.HighWord.Bits.Dpl);
if (info.HighWord.Bits.Granularity)
- puts_filtered ("Page granular.\n");
+ gdb_puts ("Page granular.\n");
else
- puts_filtered ("Byte granular.\n");
+ gdb_puts ("Byte granular.\n");
return 1;
}
else
{
if (inferior_ptid == null_ptid)
{
- puts_filtered ("Impossible to display selectors now.\n");
+ gdb_puts ("Impossible to display selectors now.\n");
return;
}
#ifdef __x86_64__
if (wow64_process)
{
- puts_filtered ("Selector $cs\n");
+ gdb_puts ("Selector $cs\n");
display_selector (current_windows_thread->h,
current_windows_thread->wow64_context.SegCs);
- puts_filtered ("Selector $ds\n");
+ gdb_puts ("Selector $ds\n");
display_selector (current_windows_thread->h,
current_windows_thread->wow64_context.SegDs);
- puts_filtered ("Selector $es\n");
+ gdb_puts ("Selector $es\n");
display_selector (current_windows_thread->h,
current_windows_thread->wow64_context.SegEs);
- puts_filtered ("Selector $ss\n");
+ gdb_puts ("Selector $ss\n");
display_selector (current_windows_thread->h,
current_windows_thread->wow64_context.SegSs);
- puts_filtered ("Selector $fs\n");
+ gdb_puts ("Selector $fs\n");
display_selector (current_windows_thread->h,
current_windows_thread->wow64_context.SegFs);
- puts_filtered ("Selector $gs\n");
+ gdb_puts ("Selector $gs\n");
display_selector (current_windows_thread->h,
current_windows_thread->wow64_context.SegGs);
}
else
#endif
{
- puts_filtered ("Selector $cs\n");
+ gdb_puts ("Selector $cs\n");
display_selector (current_windows_thread->h,
current_windows_thread->context.SegCs);
- puts_filtered ("Selector $ds\n");
+ gdb_puts ("Selector $ds\n");
display_selector (current_windows_thread->h,
current_windows_thread->context.SegDs);
- puts_filtered ("Selector $es\n");
+ gdb_puts ("Selector $es\n");
display_selector (current_windows_thread->h,
current_windows_thread->context.SegEs);
- puts_filtered ("Selector $ss\n");
+ gdb_puts ("Selector $ss\n");
display_selector (current_windows_thread->h,
current_windows_thread->context.SegSs);
- puts_filtered ("Selector $fs\n");
+ gdb_puts ("Selector $fs\n");
display_selector (current_windows_thread->h,
current_windows_thread->context.SegFs);
- puts_filtered ("Selector $gs\n");
+ gdb_puts ("Selector $gs\n");
display_selector (current_windows_thread->h,
current_windows_thread->context.SegGs);
}
projects / binutils-gdb.git / commitdiff