mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-21 04:25:45 -04:00
9666ba7526
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
117 lines
3.7 KiB
C++
117 lines
3.7 KiB
C++
//===-- SBSourceManager.cpp -------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/API/SBSourceManager.h"
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBTarget.h"
|
|
|
|
#include "lldb/API/SBFileSpec.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/SourceManager.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
|
|
#include "lldb/Target/Target.h"
|
|
|
|
namespace lldb_private {
|
|
class SourceManagerImpl {
|
|
public:
|
|
SourceManagerImpl(const lldb::DebuggerSP &debugger_sp)
|
|
: m_debugger_wp(debugger_sp), m_target_wp() {}
|
|
|
|
SourceManagerImpl(const lldb::TargetSP &target_sp)
|
|
: m_debugger_wp(), m_target_wp(target_sp) {}
|
|
|
|
SourceManagerImpl(const SourceManagerImpl &rhs) {
|
|
if (&rhs == this)
|
|
return;
|
|
m_debugger_wp = rhs.m_debugger_wp;
|
|
m_target_wp = rhs.m_target_wp;
|
|
}
|
|
|
|
size_t DisplaySourceLinesWithLineNumbers(const lldb_private::FileSpec &file,
|
|
uint32_t line, uint32_t column,
|
|
uint32_t context_before,
|
|
uint32_t context_after,
|
|
const char *current_line_cstr,
|
|
lldb_private::Stream *s) {
|
|
if (!file)
|
|
return 0;
|
|
|
|
lldb::TargetSP target_sp(m_target_wp.lock());
|
|
if (target_sp) {
|
|
return target_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers(
|
|
file, line, column, context_before, context_after, current_line_cstr,
|
|
s);
|
|
} else {
|
|
lldb::DebuggerSP debugger_sp(m_debugger_wp.lock());
|
|
if (debugger_sp) {
|
|
return debugger_sp->GetSourceManager()
|
|
.DisplaySourceLinesWithLineNumbers(file, line, column,
|
|
context_before, context_after,
|
|
current_line_cstr, s);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
lldb::DebuggerWP m_debugger_wp;
|
|
lldb::TargetWP m_target_wp;
|
|
};
|
|
}
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
SBSourceManager::SBSourceManager(const SBDebugger &debugger) {
|
|
m_opaque_ap.reset(new SourceManagerImpl(debugger.get_sp()));
|
|
}
|
|
|
|
SBSourceManager::SBSourceManager(const SBTarget &target) {
|
|
m_opaque_ap.reset(new SourceManagerImpl(target.GetSP()));
|
|
}
|
|
|
|
SBSourceManager::SBSourceManager(const SBSourceManager &rhs) {
|
|
if (&rhs == this)
|
|
return;
|
|
|
|
m_opaque_ap.reset(new SourceManagerImpl(*(rhs.m_opaque_ap.get())));
|
|
}
|
|
|
|
const lldb::SBSourceManager &SBSourceManager::
|
|
operator=(const lldb::SBSourceManager &rhs) {
|
|
m_opaque_ap.reset(new SourceManagerImpl(*(rhs.m_opaque_ap.get())));
|
|
return *this;
|
|
}
|
|
|
|
SBSourceManager::~SBSourceManager() {}
|
|
|
|
size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
|
|
const SBFileSpec &file, uint32_t line, uint32_t context_before,
|
|
uint32_t context_after, const char *current_line_cstr, SBStream &s) {
|
|
const uint32_t column = 0;
|
|
return DisplaySourceLinesWithLineNumbersAndColumn(
|
|
file.ref(), line, column, context_before, context_after,
|
|
current_line_cstr, s);
|
|
}
|
|
|
|
size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(
|
|
const SBFileSpec &file, uint32_t line, uint32_t column,
|
|
uint32_t context_before, uint32_t context_after,
|
|
const char *current_line_cstr, SBStream &s) {
|
|
if (m_opaque_ap.get() == NULL)
|
|
return 0;
|
|
|
|
return m_opaque_ap->DisplaySourceLinesWithLineNumbers(
|
|
file.ref(), line, column, context_before, context_after,
|
|
current_line_cstr, s.get());
|
|
}
|