mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2026-08-27 00:26:02 -04:00
1d6655e451
This patch changes escape_buffering_file and no_terminal_escape_file to be template classes. Currently these both derive from stdio_file, but in a coming patch that won't be desirable. This change makes it easy to instantiate these classes in a couple of different ways. The implementation is hidden and so explicit instantiations are done in ui-file.c. This seems fine since in practice there aren't going to be many of these.
391 lines
11 KiB
C
391 lines
11 KiB
C
/* Command-line output logging for GDB, the GNU debugger.
|
|
|
|
Copyright (C) 2003-2026 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "cli/cli-cmds.h"
|
|
#include "ui-out.h"
|
|
#include "interps.h"
|
|
#include "logging-file.h"
|
|
#include "cli/cli-style.h"
|
|
#include "cli/cli-decode.h"
|
|
|
|
static std::string saved_filename;
|
|
|
|
static void
|
|
maybe_warn_already_logging ()
|
|
{
|
|
if (!saved_filename.empty ())
|
|
warning (_("Currently logging to %ps. Turn the logging off and on to "
|
|
"make the new setting effective."),
|
|
styled_string (file_name_style.style (),
|
|
saved_filename.c_str ()));
|
|
}
|
|
|
|
static std::string logging_filename = "gdb.txt";
|
|
|
|
static void
|
|
set_logging_filename (const char *args,
|
|
int from_tty, struct cmd_list_element *c)
|
|
{
|
|
maybe_warn_already_logging ();
|
|
}
|
|
|
|
static void
|
|
show_logging_filename (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
gdb_printf (file, _("The current logfile is \"%ps\".\n"),
|
|
styled_string (file_name_style.style (), value));
|
|
}
|
|
|
|
static bool logging_overwrite;
|
|
|
|
static void
|
|
set_logging_overwrite (const char *args,
|
|
int from_tty, struct cmd_list_element *c)
|
|
{
|
|
maybe_warn_already_logging ();
|
|
}
|
|
|
|
static void
|
|
show_logging_overwrite (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
if (logging_overwrite)
|
|
gdb_printf (file, _("on: Logging overwrites the log file.\n"));
|
|
else
|
|
gdb_printf (file, _("off: Logging appends to the log file.\n"));
|
|
}
|
|
|
|
/* The current log file, or nullptr if none. */
|
|
static ui_file_up log_file;
|
|
|
|
/* Value as configured by the user. */
|
|
static bool logging_redirect;
|
|
static bool debug_redirect;
|
|
|
|
static void
|
|
set_logging_redirect (const char *args,
|
|
int from_tty, struct cmd_list_element *c)
|
|
{
|
|
maybe_warn_already_logging ();
|
|
}
|
|
|
|
static void
|
|
show_logging_redirect (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
if (logging_redirect)
|
|
gdb_printf (file, _("on: Output will go only to the log file.\n"));
|
|
else
|
|
gdb_printf
|
|
(file,
|
|
_("off: Output will go to both the screen and the log file.\n"));
|
|
}
|
|
|
|
static void
|
|
show_logging_debug_redirect (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
if (debug_redirect)
|
|
gdb_printf (file, _("on: Debug output will go only to the log file.\n"));
|
|
else
|
|
gdb_printf
|
|
(file,
|
|
_("off: Debug output will go to both the screen and the log file.\n"));
|
|
}
|
|
|
|
/* Values as used by the logging_file implementation. These are
|
|
separate and only set when logging is enabled, because historically
|
|
gdb required you to disable and re-enable logging to change these
|
|
settings. */
|
|
|
|
static bool logging_redirect_for_file;
|
|
static bool debug_redirect_for_file;
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
bool
|
|
logging_file<T>::ordinary_output () const
|
|
{
|
|
if (log_file == nullptr)
|
|
return true;
|
|
if (logging_redirect_for_file)
|
|
return false;
|
|
if (debug_redirect_for_file)
|
|
return !m_for_stdlog;
|
|
return true;
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
void
|
|
logging_file<T>::flush ()
|
|
{
|
|
if (log_file != nullptr)
|
|
log_file->flush ();
|
|
/* Always flushing seems fine. */
|
|
m_out->flush ();
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
bool
|
|
logging_file<T>::can_page () const
|
|
{
|
|
/* If all output is redirected, do not page. */
|
|
if (!ordinary_output ())
|
|
return false;
|
|
/* In other cases, paging happens if the underlying stream can
|
|
page. */
|
|
return m_out->can_page ();
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
void
|
|
logging_file<T>::write (const char *buf, long length_buf)
|
|
{
|
|
if (log_file != nullptr)
|
|
log_file->write (buf, length_buf);
|
|
if (ordinary_output ())
|
|
m_out->write (buf, length_buf);
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
void
|
|
logging_file<T>::write_async_safe (const char *buf, long length_buf)
|
|
{
|
|
if (log_file != nullptr)
|
|
log_file->write_async_safe (buf, length_buf);
|
|
if (ordinary_output ())
|
|
m_out->write_async_safe (buf, length_buf);
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
void
|
|
logging_file<T>::puts (const char *linebuffer)
|
|
{
|
|
if (log_file != nullptr)
|
|
log_file->puts (linebuffer);
|
|
if (ordinary_output ())
|
|
m_out->puts (linebuffer);
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
void
|
|
logging_file<T>::emit_style_escape (const ui_file_style &style)
|
|
{
|
|
if (log_file != nullptr)
|
|
log_file->emit_style_escape (style);
|
|
if (ordinary_output ())
|
|
m_out->emit_style_escape (style);
|
|
}
|
|
|
|
/* See logging-file.h. */
|
|
|
|
template<typename T>
|
|
void
|
|
logging_file<T>::puts_unfiltered (const char *str)
|
|
{
|
|
if (log_file != nullptr)
|
|
log_file->puts_unfiltered (str);
|
|
if (ordinary_output ())
|
|
m_out->puts_unfiltered (str);
|
|
}
|
|
|
|
/* The available instantiations of logging_file. */
|
|
template class logging_file<ui_file *>;
|
|
template class logging_file<ui_file_up>;
|
|
|
|
/* This is a helper for the `set logging' command. */
|
|
static void
|
|
handle_redirections (int from_tty)
|
|
{
|
|
if (!saved_filename.empty ())
|
|
{
|
|
gdb_printf ("Already logging to %ps.\n",
|
|
styled_string (file_name_style.style (),
|
|
saved_filename.c_str ()));
|
|
return;
|
|
}
|
|
|
|
stdio_file_up log = std::make_unique<no_terminal_escape_file<stdio_file>> ();
|
|
if (!log->open (logging_filename.c_str (), logging_overwrite ? "w" : "a"))
|
|
perror_with_name (_("set logging"));
|
|
|
|
/* Redirects everything to gdb_stdout while this is running. */
|
|
if (from_tty)
|
|
{
|
|
if (!logging_redirect)
|
|
gdb_printf ("Copying output to %ps.\n",
|
|
styled_string (file_name_style.style (),
|
|
logging_filename.c_str ()));
|
|
else
|
|
gdb_printf ("Redirecting output to %ps.\n",
|
|
styled_string (file_name_style.style (),
|
|
logging_filename.c_str ()));
|
|
|
|
if (!debug_redirect)
|
|
gdb_printf ("Copying debug output to %ps.\n",
|
|
styled_string (file_name_style.style (),
|
|
logging_filename.c_str ()));
|
|
else
|
|
gdb_printf ("Redirecting debug output to %ps.\n",
|
|
styled_string (file_name_style.style (),
|
|
logging_filename.c_str ()));
|
|
}
|
|
|
|
saved_filename = logging_filename;
|
|
logging_redirect_for_file = logging_redirect;
|
|
debug_redirect_for_file = debug_redirect;
|
|
log_file = std::move (log);
|
|
}
|
|
|
|
static void
|
|
set_logging_on (const char *args, int from_tty)
|
|
{
|
|
const char *rest = args;
|
|
|
|
if (rest && *rest)
|
|
logging_filename = rest;
|
|
|
|
handle_redirections (from_tty);
|
|
}
|
|
|
|
static void
|
|
set_logging_off (const char *args, int from_tty)
|
|
{
|
|
if (saved_filename.empty ())
|
|
return;
|
|
|
|
log_file.reset ();
|
|
if (from_tty)
|
|
gdb_printf ("Done logging to %ps.\n",
|
|
styled_string (file_name_style.style (),
|
|
saved_filename.c_str ()));
|
|
|
|
saved_filename.clear ();
|
|
}
|
|
|
|
static bool logging_enabled;
|
|
|
|
static void
|
|
set_logging_enabled (const char *args,
|
|
int from_tty, struct cmd_list_element *c)
|
|
{
|
|
if (logging_enabled)
|
|
set_logging_on (args, from_tty);
|
|
else
|
|
set_logging_off (args, from_tty);
|
|
}
|
|
|
|
static void
|
|
show_logging_enabled (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
if (logging_enabled)
|
|
gdb_printf (file, _("on: Logging is enabled.\n"));
|
|
else
|
|
gdb_printf (file, _("off: Logging is disabled.\n"));
|
|
}
|
|
|
|
INIT_GDB_FILE (cli_logging)
|
|
{
|
|
static struct cmd_list_element *set_logging_cmdlist, *show_logging_cmdlist;
|
|
|
|
/* Set/show logging. */
|
|
add_setshow_prefix_cmd ("logging", class_support,
|
|
_("Set logging options."),
|
|
_("Show logging options."),
|
|
&set_logging_cmdlist, &show_logging_cmdlist,
|
|
&setlist, &showlist);
|
|
|
|
/* Set/show logging overwrite. */
|
|
add_setshow_boolean_cmd ("overwrite", class_support, &logging_overwrite, _("\
|
|
Set whether logging overwrites or appends to the log file."), _("\
|
|
Show whether logging overwrites or appends to the log file."), _("\
|
|
If set, logging overwrites the log file."),
|
|
set_logging_overwrite,
|
|
show_logging_overwrite,
|
|
&set_logging_cmdlist, &show_logging_cmdlist);
|
|
|
|
/* Set/show logging redirect. */
|
|
add_setshow_boolean_cmd ("redirect", class_support, &logging_redirect, _("\
|
|
Set the logging output mode."), _("\
|
|
Show the logging output mode."), _("\
|
|
If redirect is off, output will go to both the screen and the log file.\n\
|
|
If redirect is on, output will go only to the log file."),
|
|
set_logging_redirect,
|
|
show_logging_redirect,
|
|
&set_logging_cmdlist, &show_logging_cmdlist);
|
|
|
|
/* Set/show logging debugredirect. */
|
|
add_setshow_boolean_cmd ("debugredirect", class_support,
|
|
&debug_redirect, _("\
|
|
Set the logging debug output mode."), _("\
|
|
Show the logging debug output mode."), _("\
|
|
If debug redirect is off, debug will go to both the screen and the log file.\n\
|
|
If debug redirect is on, debug will go only to the log file."),
|
|
set_logging_redirect,
|
|
show_logging_debug_redirect,
|
|
&set_logging_cmdlist, &show_logging_cmdlist);
|
|
|
|
/* Set/show logging file. */
|
|
add_setshow_filename_cmd ("file", class_support, &logging_filename, _("\
|
|
Set the current logfile."), _("\
|
|
Show the current logfile."), _("\
|
|
The logfile is used when directing GDB's output."),
|
|
set_logging_filename,
|
|
show_logging_filename,
|
|
&set_logging_cmdlist, &show_logging_cmdlist);
|
|
|
|
/* Set/show logging enabled. */
|
|
set_show_commands setshow_logging_enabled_cmds
|
|
= add_setshow_boolean_cmd ("enabled", class_support, &logging_enabled,
|
|
_("Enable logging."),
|
|
_("Show whether logging is enabled."),
|
|
_("When on, enable logging."),
|
|
set_logging_enabled,
|
|
show_logging_enabled,
|
|
&set_logging_cmdlist, &show_logging_cmdlist);
|
|
|
|
/* Set logging on, deprecated alias. */
|
|
cmd_list_element *set_logging_on_cmd
|
|
= add_alias_cmd ("on", setshow_logging_enabled_cmds.set, class_support,
|
|
false, &set_logging_cmdlist);
|
|
deprecate_cmd (set_logging_on_cmd, "set logging enabled on");
|
|
set_logging_on_cmd->default_args = "on";
|
|
|
|
/* Set logging off, deprecated alias. */
|
|
cmd_list_element *set_logging_off_cmd
|
|
= add_alias_cmd ("off", setshow_logging_enabled_cmds.set, class_support,
|
|
false, &set_logging_cmdlist);
|
|
deprecate_cmd (set_logging_off_cmd, "set logging enabled off");
|
|
set_logging_off_cmd->default_args = "off";
|
|
}
|