2
0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-21 04:42:53 +08:00
binutils-gdb/gdb/source-cache.c
Philippe Waroquiers 8a522c6cab Have 'thread|frame apply' style their output.
'thread|frame apply CMD' launches CMD so that CMD output goes to a string_file.
This patch ensures that string_file for such CMD output contains
style escape sequences that 'thread|frame apply' will later on
output on the real terminal, so as to have CMD output properly styled.

The idea is to have the class ui_file having overridable methods
to indicate that the output to this ui_file should be done using
'terminal' behaviour such as styling.
Then these methods are overriden in string_file so that a specially
constructed string_file will get output with style escape sequences.

After this patch, the output of CMD by thread|frame apply CMD is styled
similarly as when CMD is launched directly.
Note that string_file (term_out true) could also support wrapping,
but this is not done (yet?).

Tested on debian/amd64.

gdb/ChangeLog
2019-04-27  Philippe Waroquiers  <philippe.waroquiers@skynet.be>

	Support style in 'frame|thread apply'

	* gdbcmd.h (execute_command_to_string): New term_out parameter.
	* record.c (record_start, record_stop): Update callers of
	execute_command_to_string with false.
	* ui-file.h (class ui_file): New term_out and can_emit_style_escape
	methods.
	(class string_file): New constructor with term_out parameter.
	Override methods term_out and can_emit_style_escape.  New member
	term_out.
	(class stdio_file): Override can_emit_style_escape.
	(class tee_file): Override term_out and can_emit_style_escape.
	* utils.h (can_emit_style_escape): Remove.
	* utils.c (can_emit_style_escape): Likewise.
	Update all callers of can_emit_style_escape (SOMESTREAM) to
	SOMESTREAM->can_emit_style_escape.
	* source-cache.c (source_cache::get_source_lines): Likewise.
	* stack.c (frame_apply_command_count): Call execute_command_to_string
	passing the term_out characteristic of the current gdb_stdout.
	* thread.c (thr_try_catch_cmd): Likewise.
	* top.c (execute_command_to_string): pass term_out parameter
	to construct the string_file for the command output.
	* ui-file.c (term_cli_styling): New function (most code moved
	from utils.c can_emit_style_escape).
	(string_file::string_file, string_file::can_emit_style_escape,
	stdio_file::can_emit_style_escape, tee_file::term_out,
	tee_file::can_emit_style_escape): New functions.
2019-04-27 14:25:28 +02:00

238 lines
5.9 KiB
C

/* Cache of styled source file text
Copyright (C) 2018-2019 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 "defs.h"
#include "source-cache.h"
#include "common/scoped_fd.h"
#include "source.h"
#include "cli/cli-style.h"
#ifdef HAVE_SOURCE_HIGHLIGHT
/* If Gnulib redirects 'open' and 'close' to its replacements
'rpl_open' and 'rpl_close' via cpp macros, including <fstream>
below with those macros in effect will cause unresolved externals
when GDB is linked. Happens, e.g., in the MinGW build. */
#undef open
#undef close
#include <fstream>
#include <sstream>
#include <srchilite/sourcehighlight.h>
#include <srchilite/langmap.h>
#endif
/* The number of source files we'll cache. */
#define MAX_ENTRIES 5
/* See source-cache.h. */
source_cache g_source_cache;
/* See source-cache.h. */
bool
source_cache::get_plain_source_lines (struct symtab *s, int first_line,
int last_line, std::string *lines)
{
scoped_fd desc (open_source_file (s));
if (desc.get () < 0)
return false;
if (s->line_charpos == 0)
find_source_lines (s, desc.get ());
if (first_line < 1 || first_line > s->nlines || last_line < 1)
return false;
if (lseek (desc.get (), s->line_charpos[first_line - 1], SEEK_SET) < 0)
perror_with_name (symtab_to_filename_for_display (s));
int last_charpos;
if (last_line >= s->nlines)
{
struct stat st;
if (fstat (desc.get (), &st) < 0)
perror_with_name (symtab_to_filename_for_display (s));
/* We could cache this in line_charpos... */
last_charpos = st.st_size;
}
else
last_charpos = s->line_charpos[last_line];
lines->resize (last_charpos - s->line_charpos[first_line - 1]);
if (myread (desc.get (), &(*lines)[0], lines->size ()) < 0)
perror_with_name (symtab_to_filename_for_display (s));
return true;
}
/* See source-cache.h. */
std::string
source_cache::extract_lines (const struct source_text &text, int first_line,
int last_line)
{
int lineno = 1;
std::string::size_type pos = 0;
std::string::size_type first_pos = std::string::npos;
while (pos != std::string::npos && lineno <= last_line)
{
std::string::size_type new_pos = text.contents.find ('\n', pos);
if (lineno == first_line)
first_pos = pos;
pos = new_pos;
if (lineno == last_line || pos == std::string::npos)
{
if (first_pos == std::string::npos)
return {};
if (pos == std::string::npos)
pos = text.contents.size ();
return text.contents.substr (first_pos, pos - first_pos);
}
++lineno;
++pos;
}
return {};
}
#ifdef HAVE_SOURCE_HIGHLIGHT
/* Return the Source Highlight language name, given a gdb language
LANG. Returns NULL if the language is not known. */
static const char *
get_language_name (enum language lang)
{
switch (lang)
{
case language_c:
case language_objc:
return "c.lang";
case language_cplus:
return "cpp.lang";
case language_d:
return "d.lang";
case language_go:
return "go.lang";
case language_fortran:
return "fortran.lang";
case language_m2:
/* Not handled by Source Highlight. */
break;
case language_asm:
return "asm.lang";
case language_pascal:
return "pascal.lang";
case language_opencl:
/* Not handled by Source Highlight. */
break;
case language_rust:
/* Not handled by Source Highlight. */
break;
case language_ada:
return "ada.lang";
default:
break;
}
return nullptr;
}
#endif /* HAVE_SOURCE_HIGHLIGHT */
/* See source-cache.h. */
bool
source_cache::get_source_lines (struct symtab *s, int first_line,
int last_line, std::string *lines)
{
if (first_line < 1 || last_line < 1 || first_line > last_line)
return false;
#ifdef HAVE_SOURCE_HIGHLIGHT
if (source_styling && gdb_stdout->can_emit_style_escape ())
{
const char *fullname = symtab_to_fullname (s);
for (const auto &item : m_source_map)
{
if (item.fullname == fullname)
{
*lines = extract_lines (item, first_line, last_line);
return true;
}
}
const char *lang_name = get_language_name (SYMTAB_LANGUAGE (s));
if (lang_name != nullptr)
{
std::ifstream input (fullname);
if (input.is_open ())
{
if (s->line_charpos == 0)
{
scoped_fd desc = open_source_file (s);
if (desc.get () < 0)
return false;
find_source_lines (s, desc.get ());
/* FULLNAME points to a value owned by the symtab
(symtab::fullname). Calling open_source_file reallocates
that value, so we must refresh FULLNAME to avoid a
use-after-free. */
fullname = symtab_to_fullname (s);
}
srchilite::SourceHighlight highlighter ("esc.outlang");
highlighter.setStyleFile("esc.style");
std::ostringstream output;
highlighter.highlight (input, output, lang_name, fullname);
source_text result = { fullname, output.str () };
m_source_map.push_back (std::move (result));
if (m_source_map.size () > MAX_ENTRIES)
m_source_map.erase (m_source_map.begin ());
*lines = extract_lines (m_source_map.back (), first_line,
last_line);
return true;
}
}
}
#endif /* HAVE_SOURCE_HIGHLIGHT */
return get_plain_source_lines (s, first_line, last_line, lines);
}