2010-06-09 00:52:24 +08:00
|
|
|
//===-- SourceManager.cpp ---------------------------------------*- C++ -*-===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-06-09 00:52:24 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "lldb/Core/SourceManager.h"
|
|
|
|
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Core/Address.h"
|
|
|
|
#include "lldb/Core/AddressRange.h"
|
2011-09-13 08:29:56 +08:00
|
|
|
#include "lldb/Core/Debugger.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Core/FormatEntity.h"
|
2018-08-02 08:30:15 +08:00
|
|
|
#include "lldb/Core/Highlighter.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Core/Module.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Core/ModuleList.h"
|
2016-11-02 00:11:14 +08:00
|
|
|
#include "lldb/Host/FileSystem.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Symbol/CompileUnit.h"
|
|
|
|
#include "lldb/Symbol/Function.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Symbol/LineEntry.h"
|
Added a new option to the "source list" command that allows us to see where
line tables specify breakpoints can be set in the source. When dumping the
source, the number of breakpoints that can be set on a source line are shown
as a prefix:
(lldb) source list -f test.c -l1 -c222 -b
1 #include <stdio.h>
2 #include <sys/fcntl.h>
3 #include <unistd.h>
4 int
5 sleep_loop (const int num_secs)
[2] 6 {
7 int i;
[1] 8 for (i=0; i<num_secs; ++i)
9 {
[1] 10 printf("%d of %i - sleep(1);\n", i, num_secs);
[1] 11 sleep(1);
12 }
13 return 0;
[1] 14 }
15
16 int
17 main (int argc, char const* argv[])
[1] 18 {
[1] 19 printf("Process: %i\n\n", getpid());
[1] 20 puts("Press any key to continue..."); getchar();
[1] 21 sleep_loop (20);
22 return 12;
[1] 23 }
Above we can see there are two breakpoints for line 6 and one breakpoint for
lines 8, 10, 11, 14, 18, 19, 20, 21 and 23. All other lines have no line table
entries for them. This helps visualize the data provided in the debug
information without having to manually dump all line tables. It also includes
all inline breakpoint that may result for a given file which can also be very
handy to see.
llvm-svn: 129747
2011-04-19 12:19:37 +08:00
|
|
|
#include "lldb/Symbol/SymbolContext.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Target/PathMappingList.h"
|
2011-04-23 10:04:55 +08:00
|
|
|
#include "lldb/Target/Target.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Utility/ConstString.h"
|
2017-03-04 09:30:05 +08:00
|
|
|
#include "lldb/Utility/DataBuffer.h"
|
2017-03-07 07:42:14 +08:00
|
|
|
#include "lldb/Utility/DataBufferLLVM.h"
|
2017-02-03 05:39:50 +08:00
|
|
|
#include "lldb/Utility/RegularExpression.h"
|
|
|
|
#include "lldb/Utility/Stream.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/lldb-enumerations.h"
|
2017-04-07 05:28:29 +08:00
|
|
|
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "llvm/ADT/Twine.h"
|
2017-04-07 05:28:29 +08:00
|
|
|
|
|
|
|
#include <memory>
|
2018-11-12 07:16:43 +08:00
|
|
|
#include <utility>
|
2017-04-07 05:28:29 +08:00
|
|
|
|
2018-11-12 07:16:43 +08:00
|
|
|
#include <assert.h>
|
|
|
|
#include <stdio.h>
|
2017-04-07 05:28:29 +08:00
|
|
|
|
|
|
|
namespace lldb_private {
|
|
|
|
class ExecutionContext;
|
|
|
|
}
|
|
|
|
namespace lldb_private {
|
|
|
|
class ValueObject;
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2013-03-19 08:20:55 +08:00
|
|
|
using namespace lldb;
|
2010-06-09 00:52:24 +08:00
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
static inline bool is_newline_char(char ch) { return ch == '\n' || ch == '\r'; }
|
|
|
|
|
|
|
|
// SourceManager constructor
|
2013-03-19 08:20:55 +08:00
|
|
|
SourceManager::SourceManager(const TargetSP &target_sp)
|
2011-10-08 06:16:04 +08:00
|
|
|
: m_last_file_sp(), m_last_line(0), m_last_count(0), m_default_set(false),
|
2013-03-19 08:20:55 +08:00
|
|
|
m_target_wp(target_sp),
|
|
|
|
m_debugger_wp(target_sp->GetDebugger().shared_from_this()) {}
|
2011-09-13 08:29:56 +08:00
|
|
|
|
2013-03-19 08:20:55 +08:00
|
|
|
SourceManager::SourceManager(const DebuggerSP &debugger_sp)
|
2011-10-08 06:16:04 +08:00
|
|
|
: m_last_file_sp(), m_last_line(0), m_last_count(0), m_default_set(false),
|
2013-03-19 08:20:55 +08:00
|
|
|
m_target_wp(), m_debugger_wp(debugger_sp) {}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
// Destructor
|
|
|
|
SourceManager::~SourceManager() {}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-09-09 06:13:49 +08:00
|
|
|
SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
|
2013-03-15 06:52:17 +08:00
|
|
|
bool same_as_previous =
|
[lldb] s/FileSpec::Equal/FileSpec::Match
Summary:
The FileSpec class is often used as a sort of a pattern -- one specifies
a bare file name to search, and we check if in matches the full file
name of an existing module (for example).
These comparisons used FileSpec::Equal, which had some support for it
(via the full=false argument), but it was not a good fit for this job.
For one, it did a symmetric comparison, which makes sense for a function
called "equal", but not for typical searches (when searching for
"/foo/bar.so", we don't want to find a module whose name is just
"bar.so"). This resulted in patterns like:
if (FileSpec::Equal(pattern, file, pattern.GetDirectory()))
which would request a "full" match only if the pattern really contained
a directory. This worked, but the intended behavior was very unobvious.
On top of that, a lot of the code wanted to handle the case of an
"empty" pattern, and treat it as matching everything. This resulted in
conditions like:
if (pattern && !FileSpec::Equal(pattern, file, pattern.GetDirectory())
which are nearly impossible to decipher.
This patch introduces a FileSpec::Match function, which does exactly
what most of FileSpec::Equal callers want, an asymmetric match between a
"pattern" FileSpec and a an actual FileSpec. Empty paterns match
everything, filename-only patterns match only the filename component.
I've tried to update all callers of FileSpec::Equal to use a simpler
interface. Those that hardcoded full=true have been changed to use
operator==. Those passing full=pattern.GetDirectory() have been changed
to use FileSpec::Match.
There was also a handful of places which hardcoded full=false. I've
changed these to use FileSpec::Match too. This is a slight change in
semantics, but it does not look like that was ever intended, and it was
more likely a result of a misunderstanding of the "proper" way to use
FileSpec::Equal.
[In an ideal world a "FileSpec" and a "FileSpec pattern" would be two
different types, but given how widespread FileSpec is, it is unlikely
we'll get there in one go. This at least provides a good starting point
by centralizing all matching behavior.]
Reviewers: teemperor, JDevlieghere, jdoerfert
Subscribers: emaste, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D70851
2019-11-29 18:31:00 +08:00
|
|
|
m_last_file_sp &&
|
|
|
|
FileSpec::Match(file_spec, m_last_file_sp->GetFileSpec());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-19 08:20:55 +08:00
|
|
|
DebuggerSP debugger_sp(m_debugger_wp.lock());
|
2010-06-09 00:52:24 +08:00
|
|
|
FileSP file_sp;
|
2013-03-15 06:52:17 +08:00
|
|
|
if (same_as_previous)
|
|
|
|
file_sp = m_last_file_sp;
|
2013-03-19 08:20:55 +08:00
|
|
|
else if (debugger_sp)
|
|
|
|
file_sp = debugger_sp->GetSourceFileCache().FindSourceFile(file_spec);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-19 08:20:55 +08:00
|
|
|
TargetSP target_sp(m_target_wp.lock());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-15 06:52:17 +08:00
|
|
|
// It the target source path map has been updated, get this file again so we
|
|
|
|
// can successfully remap the source file
|
2013-03-19 08:20:55 +08:00
|
|
|
if (target_sp && file_sp &&
|
|
|
|
file_sp->GetSourceMapModificationID() !=
|
|
|
|
target_sp->GetSourcePathMap().GetModificationID())
|
2013-03-15 06:52:17 +08:00
|
|
|
file_sp.reset();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2015-07-30 02:37:25 +08:00
|
|
|
// Update the file contents if needed if we found a file
|
|
|
|
if (file_sp)
|
|
|
|
file_sp->UpdateIfNeeded();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-12-13 05:59:28 +08:00
|
|
|
// If file_sp is no good or it points to a non-existent file, reset it.
|
2018-11-02 01:09:25 +08:00
|
|
|
if (!file_sp || !FileSystem::Instance().Exists(file_sp->GetFileSpec())) {
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
if (target_sp)
|
2017-04-07 05:28:29 +08:00
|
|
|
file_sp = std::make_shared<File>(file_spec, target_sp.get());
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
else
|
2017-04-07 05:28:29 +08:00
|
|
|
file_sp = std::make_shared<File>(file_spec, debugger_sp);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-19 08:20:55 +08:00
|
|
|
if (debugger_sp)
|
|
|
|
debugger_sp->GetSourceFileCache().AddSourceFile(file_sp);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
return file_sp;
|
|
|
|
}
|
|
|
|
|
2018-08-02 08:30:15 +08:00
|
|
|
static bool should_highlight_source(DebuggerSP debugger_sp) {
|
|
|
|
if (!debugger_sp)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// We don't use ANSI stop column formatting if the debugger doesn't think it
|
|
|
|
// should be using color.
|
|
|
|
if (!debugger_sp->GetUseColor())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return debugger_sp->GetHighlightSource();
|
|
|
|
}
|
|
|
|
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
static bool should_show_stop_column_with_ansi(DebuggerSP debugger_sp) {
|
|
|
|
// We don't use ANSI stop column formatting if we can't lookup values from
|
|
|
|
// the debugger.
|
|
|
|
if (!debugger_sp)
|
|
|
|
return false;
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// We don't use ANSI stop column formatting if the debugger doesn't think it
|
|
|
|
// should be using color.
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
if (!debugger_sp->GetUseColor())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// We only use ANSI stop column formatting if we're either supposed to show
|
|
|
|
// ANSI where available (which we know we have when we get to this point), or
|
|
|
|
// if we're only supposed to use ANSI.
|
|
|
|
const auto value = debugger_sp->GetStopShowColumn();
|
|
|
|
return ((value == eStopShowColumnAnsiOrCaret) ||
|
|
|
|
(value == eStopShowColumnAnsi));
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool should_show_stop_column_with_caret(DebuggerSP debugger_sp) {
|
|
|
|
// We don't use text-based stop column formatting if we can't lookup values
|
|
|
|
// from the debugger.
|
|
|
|
if (!debugger_sp)
|
|
|
|
return false;
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// If we're asked to show the first available of ANSI or caret, then we do
|
|
|
|
// show the caret when ANSI is not available.
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
const auto value = debugger_sp->GetStopShowColumn();
|
|
|
|
if ((value == eStopShowColumnAnsiOrCaret) && !debugger_sp->GetUseColor())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// The only other time we use caret is if we're explicitly asked to show
|
|
|
|
// caret.
|
|
|
|
return value == eStopShowColumnCaret;
|
|
|
|
}
|
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
size_t SourceManager::DisplaySourceLinesWithLineNumbersUsingLastFile(
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
uint32_t start_line, uint32_t count, uint32_t curr_line, uint32_t column,
|
2013-03-14 02:25:49 +08:00
|
|
|
const char *current_line_cstr, Stream *s,
|
|
|
|
const SymbolContextList *bp_locs) {
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
2018-09-13 17:19:40 +08:00
|
|
|
|
|
|
|
Stream::ByteDelta delta(*s);
|
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
if (start_line == 0) {
|
|
|
|
if (m_last_line != 0 && m_last_line != UINT32_MAX)
|
2013-03-19 08:20:55 +08:00
|
|
|
start_line = m_last_line + m_last_count;
|
2016-09-07 04:57:50 +08:00
|
|
|
else
|
2013-03-14 02:25:49 +08:00
|
|
|
start_line = 1;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
if (!m_default_set) {
|
|
|
|
FileSpec tmp_spec;
|
|
|
|
uint32_t tmp_line;
|
|
|
|
GetDefaultFileAndLine(tmp_spec, tmp_line);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
m_last_line = start_line;
|
|
|
|
m_last_count = count;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (m_last_file_sp.get()) {
|
2013-03-14 02:25:49 +08:00
|
|
|
const uint32_t end_line = start_line + count - 1;
|
|
|
|
for (uint32_t line = start_line; line <= end_line; ++line) {
|
|
|
|
if (!m_last_file_sp->LineIsValid(line)) {
|
|
|
|
m_last_line = UINT32_MAX;
|
2016-09-07 04:57:50 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
Added a new option to the "source list" command that allows us to see where
line tables specify breakpoints can be set in the source. When dumping the
source, the number of breakpoints that can be set on a source line are shown
as a prefix:
(lldb) source list -f test.c -l1 -c222 -b
1 #include <stdio.h>
2 #include <sys/fcntl.h>
3 #include <unistd.h>
4 int
5 sleep_loop (const int num_secs)
[2] 6 {
7 int i;
[1] 8 for (i=0; i<num_secs; ++i)
9 {
[1] 10 printf("%d of %i - sleep(1);\n", i, num_secs);
[1] 11 sleep(1);
12 }
13 return 0;
[1] 14 }
15
16 int
17 main (int argc, char const* argv[])
[1] 18 {
[1] 19 printf("Process: %i\n\n", getpid());
[1] 20 puts("Press any key to continue..."); getchar();
[1] 21 sleep_loop (20);
22 return 12;
[1] 23 }
Above we can see there are two breakpoints for line 6 and one breakpoint for
lines 8, 10, 11, 14, 18, 19, 20, 21 and 23. All other lines have no line table
entries for them. This helps visualize the data provided in the debug
information without having to manually dump all line tables. It also includes
all inline breakpoint that may result for a given file which can also be very
handy to see.
llvm-svn: 129747
2011-04-19 12:19:37 +08:00
|
|
|
char prefix[32] = "";
|
|
|
|
if (bp_locs) {
|
2013-03-14 02:25:49 +08:00
|
|
|
uint32_t bp_count = bp_locs->NumLineEntriesWithLine(line);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Added a new option to the "source list" command that allows us to see where
line tables specify breakpoints can be set in the source. When dumping the
source, the number of breakpoints that can be set on a source line are shown
as a prefix:
(lldb) source list -f test.c -l1 -c222 -b
1 #include <stdio.h>
2 #include <sys/fcntl.h>
3 #include <unistd.h>
4 int
5 sleep_loop (const int num_secs)
[2] 6 {
7 int i;
[1] 8 for (i=0; i<num_secs; ++i)
9 {
[1] 10 printf("%d of %i - sleep(1);\n", i, num_secs);
[1] 11 sleep(1);
12 }
13 return 0;
[1] 14 }
15
16 int
17 main (int argc, char const* argv[])
[1] 18 {
[1] 19 printf("Process: %i\n\n", getpid());
[1] 20 puts("Press any key to continue..."); getchar();
[1] 21 sleep_loop (20);
22 return 12;
[1] 23 }
Above we can see there are two breakpoints for line 6 and one breakpoint for
lines 8, 10, 11, 14, 18, 19, 20, 21 and 23. All other lines have no line table
entries for them. This helps visualize the data provided in the debug
information without having to manually dump all line tables. It also includes
all inline breakpoint that may result for a given file which can also be very
handy to see.
llvm-svn: 129747
2011-04-19 12:19:37 +08:00
|
|
|
if (bp_count > 0)
|
|
|
|
::snprintf(prefix, sizeof(prefix), "[%u] ", bp_count);
|
2010-06-09 00:52:24 +08:00
|
|
|
else
|
2013-03-14 02:25:49 +08:00
|
|
|
::snprintf(prefix, sizeof(prefix), " ");
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
2018-09-13 17:19:40 +08:00
|
|
|
s->Printf("%s%2.2s %-4u\t", prefix,
|
|
|
|
line == curr_line ? current_line_cstr : "", line);
|
2018-08-30 08:09:21 +08:00
|
|
|
|
|
|
|
// So far we treated column 0 as a special 'no column value', but
|
|
|
|
// DisplaySourceLines starts counting columns from 0 (and no column is
|
|
|
|
// expressed by passing an empty optional).
|
|
|
|
llvm::Optional<size_t> columnToHighlight;
|
|
|
|
if (line == curr_line && column)
|
|
|
|
columnToHighlight = column - 1;
|
|
|
|
|
|
|
|
size_t this_line_size =
|
|
|
|
m_last_file_sp->DisplaySourceLines(line, columnToHighlight, 0, 0, s);
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
if (column != 0 && line == curr_line &&
|
|
|
|
should_show_stop_column_with_caret(m_debugger_wp.lock())) {
|
|
|
|
// Display caret cursor.
|
|
|
|
std::string src_line;
|
|
|
|
m_last_file_sp->GetLine(line, src_line);
|
2018-09-13 17:19:40 +08:00
|
|
|
s->Printf(" \t");
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
// Insert a space for every non-tab character in the source line.
|
2016-09-22 06:36:51 +08:00
|
|
|
for (size_t i = 0; i + 1 < column && i < src_line.length(); ++i)
|
2018-09-13 17:19:40 +08:00
|
|
|
s->PutChar(src_line[i] == '\t' ? '\t' : ' ');
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
// Now add the caret.
|
2018-09-13 17:19:40 +08:00
|
|
|
s->Printf("^\n");
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
}
|
2013-03-14 02:25:49 +08:00
|
|
|
if (this_line_size == 0) {
|
|
|
|
m_last_line = UINT32_MAX;
|
|
|
|
break;
|
2018-09-13 17:19:40 +08:00
|
|
|
}
|
2013-03-14 02:25:49 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2018-09-13 17:19:40 +08:00
|
|
|
return *delta;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
size_t SourceManager::DisplaySourceLinesWithLineNumbers(
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
const FileSpec &file_spec, uint32_t line, uint32_t column,
|
|
|
|
uint32_t context_before, uint32_t context_after,
|
|
|
|
const char *current_line_cstr, Stream *s,
|
2013-03-14 02:25:49 +08:00
|
|
|
const SymbolContextList *bp_locs) {
|
|
|
|
FileSP file_sp(GetFile(file_spec));
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
uint32_t start_line;
|
|
|
|
uint32_t count = context_before + context_after + 1;
|
Added a new option to the "source list" command that allows us to see where
line tables specify breakpoints can be set in the source. When dumping the
source, the number of breakpoints that can be set on a source line are shown
as a prefix:
(lldb) source list -f test.c -l1 -c222 -b
1 #include <stdio.h>
2 #include <sys/fcntl.h>
3 #include <unistd.h>
4 int
5 sleep_loop (const int num_secs)
[2] 6 {
7 int i;
[1] 8 for (i=0; i<num_secs; ++i)
9 {
[1] 10 printf("%d of %i - sleep(1);\n", i, num_secs);
[1] 11 sleep(1);
12 }
13 return 0;
[1] 14 }
15
16 int
17 main (int argc, char const* argv[])
[1] 18 {
[1] 19 printf("Process: %i\n\n", getpid());
[1] 20 puts("Press any key to continue..."); getchar();
[1] 21 sleep_loop (20);
22 return 12;
[1] 23 }
Above we can see there are two breakpoints for line 6 and one breakpoint for
lines 8, 10, 11, 14, 18, 19, 20, 21 and 23. All other lines have no line table
entries for them. This helps visualize the data provided in the debug
information without having to manually dump all line tables. It also includes
all inline breakpoint that may result for a given file which can also be very
handy to see.
llvm-svn: 129747
2011-04-19 12:19:37 +08:00
|
|
|
if (line > context_before)
|
|
|
|
start_line = line - context_before;
|
|
|
|
else
|
|
|
|
start_line = 1;
|
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
if (m_last_file_sp.get() != file_sp.get()) {
|
2011-09-13 08:29:56 +08:00
|
|
|
if (line == 0)
|
2013-03-14 02:25:49 +08:00
|
|
|
m_last_line = 0;
|
2013-03-15 06:52:17 +08:00
|
|
|
m_last_file_sp = file_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-03-14 02:25:49 +08:00
|
|
|
return DisplaySourceLinesWithLineNumbersUsingLastFile(
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
start_line, count, line, column, current_line_cstr, s, bp_locs);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
size_t SourceManager::DisplayMoreWithLineNumbers(
|
|
|
|
Stream *s, uint32_t count, bool reverse, const SymbolContextList *bp_locs) {
|
2013-01-09 11:27:33 +08:00
|
|
|
// If we get called before anybody has set a default file and line, then try
|
|
|
|
// to figure it out here.
|
2013-03-19 08:20:55 +08:00
|
|
|
const bool have_default_file_line = m_last_file_sp && m_last_line > 0;
|
2013-01-09 11:27:33 +08:00
|
|
|
if (!m_default_set) {
|
|
|
|
FileSpec tmp_spec;
|
|
|
|
uint32_t tmp_line;
|
|
|
|
GetDefaultFileAndLine(tmp_spec, tmp_line);
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (m_last_file_sp) {
|
2013-03-14 02:25:49 +08:00
|
|
|
if (m_last_line == UINT32_MAX)
|
2010-06-09 00:52:24 +08:00
|
|
|
return 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
if (reverse && m_last_line == 1)
|
2013-01-09 11:27:33 +08:00
|
|
|
return 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
if (count > 0)
|
|
|
|
m_last_count = count;
|
|
|
|
else if (m_last_count == 0)
|
|
|
|
m_last_count = 10;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-14 02:25:49 +08:00
|
|
|
if (m_last_line > 0) {
|
2013-01-09 11:27:33 +08:00
|
|
|
if (reverse) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// If this is the first time we've done a reverse, then back up one
|
|
|
|
// more time so we end up showing the chunk before the last one we've
|
|
|
|
// shown:
|
2013-03-14 02:25:49 +08:00
|
|
|
if (m_last_line > m_last_count)
|
|
|
|
m_last_line -= m_last_count;
|
2013-01-09 11:27:33 +08:00
|
|
|
else
|
2013-03-14 02:25:49 +08:00
|
|
|
m_last_line = 1;
|
|
|
|
} else if (have_default_file_line)
|
|
|
|
m_last_line += m_last_count;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else
|
2013-03-14 02:25:49 +08:00
|
|
|
m_last_line = 1;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
const uint32_t column = 0;
|
2013-03-14 02:25:49 +08:00
|
|
|
return DisplaySourceLinesWithLineNumbersUsingLastFile(
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
m_last_line, m_last_count, UINT32_MAX, column, "", s, bp_locs);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-09 06:13:49 +08:00
|
|
|
bool SourceManager::SetDefaultFileAndLine(const FileSpec &file_spec,
|
|
|
|
uint32_t line) {
|
|
|
|
FileSP old_file_sp = m_last_file_sp;
|
|
|
|
m_last_file_sp = GetFile(file_spec);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-10-08 06:16:04 +08:00
|
|
|
m_default_set = true;
|
2011-09-09 06:13:49 +08:00
|
|
|
if (m_last_file_sp) {
|
2013-03-14 02:25:49 +08:00
|
|
|
m_last_line = line;
|
2011-09-09 06:13:49 +08:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
m_last_file_sp = old_file_sp;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SourceManager::GetDefaultFileAndLine(FileSpec &file_spec, uint32_t &line) {
|
|
|
|
if (m_last_file_sp) {
|
|
|
|
file_spec = m_last_file_sp->GetFileSpec();
|
2013-03-14 02:25:49 +08:00
|
|
|
line = m_last_line;
|
2011-09-09 06:13:49 +08:00
|
|
|
return true;
|
2011-10-08 06:16:04 +08:00
|
|
|
} else if (!m_default_set) {
|
2013-03-19 08:20:55 +08:00
|
|
|
TargetSP target_sp(m_target_wp.lock());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-19 08:20:55 +08:00
|
|
|
if (target_sp) {
|
|
|
|
// If nobody has set the default file and line then try here. If there's
|
2018-05-01 00:49:04 +08:00
|
|
|
// no executable, then we will try again later when there is one.
|
|
|
|
// Otherwise, if we can't find it we won't look again, somebody will have
|
|
|
|
// to set it (for instance when we stop somewhere...)
|
2013-03-19 08:20:55 +08:00
|
|
|
Module *executable_ptr = target_sp->GetExecutableModulePointer();
|
|
|
|
if (executable_ptr) {
|
|
|
|
SymbolContextList sc_list;
|
|
|
|
ConstString main_name("main");
|
|
|
|
bool symbols_okay = false; // Force it to be a debug symbol.
|
|
|
|
bool inlines_okay = true;
|
2019-10-18 03:56:40 +08:00
|
|
|
executable_ptr->FindFunctions(main_name, nullptr,
|
|
|
|
lldb::eFunctionNameTypeBase, inlines_okay,
|
|
|
|
symbols_okay, sc_list);
|
|
|
|
size_t num_matches = sc_list.GetSize();
|
2013-03-19 08:20:55 +08:00
|
|
|
for (size_t idx = 0; idx < num_matches; idx++) {
|
|
|
|
SymbolContext sc;
|
|
|
|
sc_list.GetContextAtIndex(idx, sc);
|
|
|
|
if (sc.function) {
|
|
|
|
lldb_private::LineEntry line_entry;
|
|
|
|
if (sc.function->GetAddressRange()
|
|
|
|
.GetBaseAddress()
|
|
|
|
.CalculateSymbolContextLineEntry(line_entry)) {
|
|
|
|
SetDefaultFileAndLine(line_entry.file, line_entry.line);
|
|
|
|
file_spec = m_last_file_sp->GetFileSpec();
|
|
|
|
line = m_last_line;
|
|
|
|
return true;
|
2011-10-08 06:16:04 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-10-08 06:16:04 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-10-08 06:16:04 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-12-11 05:05:26 +08:00
|
|
|
return false;
|
2011-09-09 06:13:49 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2011-09-21 09:17:13 +08:00
|
|
|
void SourceManager::FindLinesMatchingRegex(FileSpec &file_spec,
|
2012-03-16 05:01:31 +08:00
|
|
|
RegularExpression ®ex,
|
|
|
|
uint32_t start_line,
|
|
|
|
uint32_t end_line,
|
|
|
|
std::vector<uint32_t> &match_lines) {
|
2011-09-21 09:17:13 +08:00
|
|
|
match_lines.clear();
|
|
|
|
FileSP file_sp = GetFile(file_spec);
|
|
|
|
if (!file_sp)
|
|
|
|
return;
|
|
|
|
return file_sp->FindLinesMatchingRegex(regex, start_line, end_line,
|
|
|
|
match_lines);
|
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
SourceManager::File::File(const FileSpec &file_spec,
|
|
|
|
lldb::DebuggerSP debugger_sp)
|
|
|
|
: m_file_spec_orig(file_spec), m_file_spec(file_spec),
|
2018-11-01 05:49:27 +08:00
|
|
|
m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
|
2016-11-02 00:11:14 +08:00
|
|
|
m_debugger_wp(debugger_sp) {
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
CommonInitializer(file_spec, nullptr);
|
|
|
|
}
|
|
|
|
|
2011-04-23 10:04:55 +08:00
|
|
|
SourceManager::File::File(const FileSpec &file_spec, Target *target)
|
|
|
|
: m_file_spec_orig(file_spec), m_file_spec(file_spec),
|
2018-11-01 05:49:27 +08:00
|
|
|
m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)),
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
m_debugger_wp(target ? target->GetDebugger().shared_from_this()
|
|
|
|
: DebuggerSP()) {
|
|
|
|
CommonInitializer(file_spec, target);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SourceManager::File::CommonInitializer(const FileSpec &file_spec,
|
|
|
|
Target *target) {
|
2016-11-09 22:04:08 +08:00
|
|
|
if (m_mod_time == llvm::sys::TimePoint<>()) {
|
2011-09-13 08:29:56 +08:00
|
|
|
if (target) {
|
2013-03-15 06:52:17 +08:00
|
|
|
m_source_map_mod_id = target->GetSourcePathMap().GetModificationID();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-09-13 08:29:56 +08:00
|
|
|
if (!file_spec.GetDirectory() && file_spec.GetFilename()) {
|
|
|
|
// If this is just a file name, lets see if we can find it in the
|
|
|
|
// target:
|
|
|
|
bool check_inlines = false;
|
|
|
|
SymbolContextList sc_list;
|
|
|
|
size_t num_matches =
|
|
|
|
target->GetImages().ResolveSymbolContextForFilePath(
|
|
|
|
file_spec.GetFilename().AsCString(), 0, check_inlines,
|
2018-10-26 04:45:19 +08:00
|
|
|
SymbolContextItem(eSymbolContextModule |
|
|
|
|
eSymbolContextCompUnit),
|
2013-03-19 08:20:55 +08:00
|
|
|
sc_list);
|
2011-09-13 08:29:56 +08:00
|
|
|
bool got_multiple = false;
|
|
|
|
if (num_matches != 0) {
|
|
|
|
if (num_matches > 1) {
|
|
|
|
SymbolContext sc;
|
2019-11-28 23:22:44 +08:00
|
|
|
CompileUnit *test_cu = nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-09-13 08:29:56 +08:00
|
|
|
for (unsigned i = 0; i < num_matches; i++) {
|
|
|
|
sc_list.GetContextAtIndex(i, sc);
|
|
|
|
if (sc.comp_unit) {
|
2019-11-28 23:22:44 +08:00
|
|
|
if (test_cu) {
|
|
|
|
if (test_cu != sc.comp_unit)
|
2011-09-13 08:29:56 +08:00
|
|
|
got_multiple = true;
|
2011-12-13 05:59:28 +08:00
|
|
|
break;
|
|
|
|
} else
|
2019-11-28 23:22:44 +08:00
|
|
|
test_cu = sc.comp_unit;
|
2011-12-13 05:59:28 +08:00
|
|
|
}
|
2011-09-13 08:29:56 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-09-13 08:29:56 +08:00
|
|
|
if (!got_multiple) {
|
|
|
|
SymbolContext sc;
|
|
|
|
sc_list.GetContextAtIndex(0, sc);
|
2019-11-28 23:22:44 +08:00
|
|
|
if (sc.comp_unit)
|
|
|
|
m_file_spec = sc.comp_unit->GetPrimaryFile();
|
2018-11-01 05:49:27 +08:00
|
|
|
m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-09-13 08:29:56 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-12-13 05:59:28 +08:00
|
|
|
// Try remapping if m_file_spec does not correspond to an existing file.
|
2018-11-02 01:09:25 +08:00
|
|
|
if (!FileSystem::Instance().Exists(m_file_spec)) {
|
2012-03-16 05:01:31 +08:00
|
|
|
FileSpec new_file_spec;
|
|
|
|
// Check target specific source remappings first, then fall back to
|
|
|
|
// modules objects can have individual path remappings that were
|
2018-05-01 00:49:04 +08:00
|
|
|
// detected when the debug info for a module was found. then
|
2012-03-16 05:01:31 +08:00
|
|
|
if (target->GetSourcePathMap().FindFile(m_file_spec, new_file_spec) ||
|
|
|
|
target->GetImages().FindSourceFile(m_file_spec, new_file_spec)) {
|
|
|
|
m_file_spec = new_file_spec;
|
2018-11-01 05:49:27 +08:00
|
|
|
m_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
2011-04-23 10:04:55 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2016-11-09 22:04:08 +08:00
|
|
|
if (m_mod_time != llvm::sys::TimePoint<>())
|
2018-11-13 05:24:50 +08:00
|
|
|
m_data_sp = FileSystem::Instance().CreateDataBuffer(m_file_spec);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SourceManager::File::GetLineOffset(uint32_t line) {
|
|
|
|
if (line == 0)
|
|
|
|
return UINT32_MAX;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (line == 1)
|
|
|
|
return 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (CalculateLineOffsets(line)) {
|
|
|
|
if (line < m_offsets.size())
|
|
|
|
return m_offsets[line - 1]; // yes we want "line - 1" in the index
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
return UINT32_MAX;
|
|
|
|
}
|
|
|
|
|
2014-01-28 07:43:24 +08:00
|
|
|
uint32_t SourceManager::File::GetNumLines() {
|
|
|
|
CalculateLineOffsets();
|
|
|
|
return m_offsets.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *SourceManager::File::PeekLineData(uint32_t line) {
|
|
|
|
if (!LineIsValid(line))
|
[lldb] NFC modernize codebase with modernize-use-nullptr
Summary:
NFC = [[ https://llvm.org/docs/Lexicon.html#nfc | Non functional change ]]
This commit is the result of modernizing the LLDB codebase by using
`nullptr` instread of `0` or `NULL`. See
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
for more information.
This is the command I ran and I to fix and format the code base:
```
run-clang-tidy.py \
-header-filter='.*' \
-checks='-*,modernize-use-nullptr' \
-fix ~/dev/llvm-project/lldb/.* \
-format \
-style LLVM \
-p ~/llvm-builds/debug-ninja-gcc
```
NOTE: There were also changes to `llvm/utils/unittest` but I did not
include them because I felt that maybe this library shall be updated in
isolation somehow.
NOTE: I know this is a rather large commit but it is a nobrainer in most
parts.
Reviewers: martong, espindola, shafik, #lldb, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: arsenm, jvesely, nhaehnle, hiraditya, JDevlieghere, teemperor, rnkovacs, emaste, kubamracek, nemanjai, ki.stfu, javed.absar, arichardson, kbarton, jrtc27, MaskRay, atanasyan, dexonsmith, arphaman, jfb, jsji, jdoerfert, lldb-commits, llvm-commits
Tags: #lldb, #llvm
Differential Revision: https://reviews.llvm.org/D61847
llvm-svn: 361484
2019-05-23 19:14:47 +08:00
|
|
|
return nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-01-28 07:43:24 +08:00
|
|
|
size_t line_offset = GetLineOffset(line);
|
|
|
|
if (line_offset < m_data_sp->GetByteSize())
|
|
|
|
return (const char *)m_data_sp->GetBytes() + line_offset;
|
[lldb] NFC modernize codebase with modernize-use-nullptr
Summary:
NFC = [[ https://llvm.org/docs/Lexicon.html#nfc | Non functional change ]]
This commit is the result of modernizing the LLDB codebase by using
`nullptr` instread of `0` or `NULL`. See
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
for more information.
This is the command I ran and I to fix and format the code base:
```
run-clang-tidy.py \
-header-filter='.*' \
-checks='-*,modernize-use-nullptr' \
-fix ~/dev/llvm-project/lldb/.* \
-format \
-style LLVM \
-p ~/llvm-builds/debug-ninja-gcc
```
NOTE: There were also changes to `llvm/utils/unittest` but I did not
include them because I felt that maybe this library shall be updated in
isolation somehow.
NOTE: I know this is a rather large commit but it is a nobrainer in most
parts.
Reviewers: martong, espindola, shafik, #lldb, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: arsenm, jvesely, nhaehnle, hiraditya, JDevlieghere, teemperor, rnkovacs, emaste, kubamracek, nemanjai, ki.stfu, javed.absar, arichardson, kbarton, jrtc27, MaskRay, atanasyan, dexonsmith, arphaman, jfb, jsji, jdoerfert, lldb-commits, llvm-commits
Tags: #lldb, #llvm
Differential Revision: https://reviews.llvm.org/D61847
llvm-svn: 361484
2019-05-23 19:14:47 +08:00
|
|
|
return nullptr;
|
2014-01-28 07:43:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t SourceManager::File::GetLineLength(uint32_t line,
|
|
|
|
bool include_newline_chars) {
|
|
|
|
if (!LineIsValid(line))
|
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-01-28 07:43:24 +08:00
|
|
|
size_t start_offset = GetLineOffset(line);
|
|
|
|
size_t end_offset = GetLineOffset(line + 1);
|
|
|
|
if (end_offset == UINT32_MAX)
|
|
|
|
end_offset = m_data_sp->GetByteSize();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-01-28 07:43:24 +08:00
|
|
|
if (end_offset > start_offset) {
|
|
|
|
uint32_t length = end_offset - start_offset;
|
2018-12-15 08:15:33 +08:00
|
|
|
if (!include_newline_chars) {
|
2014-01-28 07:43:24 +08:00
|
|
|
const char *line_start =
|
|
|
|
(const char *)m_data_sp->GetBytes() + start_offset;
|
|
|
|
while (length > 0) {
|
|
|
|
const char last_char = line_start[length - 1];
|
|
|
|
if ((last_char == '\r') || (last_char == '\n'))
|
|
|
|
--length;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return length;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-01-28 07:43:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
bool SourceManager::File::LineIsValid(uint32_t line) {
|
|
|
|
if (line == 0)
|
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (CalculateLineOffsets(line))
|
|
|
|
return line < m_offsets.size();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-07-30 02:37:25 +08:00
|
|
|
void SourceManager::File::UpdateIfNeeded() {
|
2010-12-09 04:16:12 +08:00
|
|
|
// TODO: use host API to sign up for file modifications to anything in our
|
|
|
|
// source cache and only update when we determine a file has been updated.
|
|
|
|
// For now we check each time we want to display info for the file.
|
2018-11-01 05:49:27 +08:00
|
|
|
auto curr_mod_time = FileSystem::Instance().GetModificationTime(m_file_spec);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-11-09 22:04:08 +08:00
|
|
|
if (curr_mod_time != llvm::sys::TimePoint<>() &&
|
|
|
|
m_mod_time != curr_mod_time) {
|
2010-12-09 04:16:12 +08:00
|
|
|
m_mod_time = curr_mod_time;
|
2018-11-13 05:24:50 +08:00
|
|
|
m_data_sp = FileSystem::Instance().CreateDataBuffer(m_file_spec);
|
2010-12-09 04:16:12 +08:00
|
|
|
m_offsets.clear();
|
|
|
|
}
|
2015-07-30 02:37:25 +08:00
|
|
|
}
|
2010-12-09 04:16:12 +08:00
|
|
|
|
2018-08-30 08:09:21 +08:00
|
|
|
size_t SourceManager::File::DisplaySourceLines(uint32_t line,
|
|
|
|
llvm::Optional<size_t> column,
|
2015-07-30 02:37:25 +08:00
|
|
|
uint32_t context_before,
|
2010-06-09 00:52:24 +08:00
|
|
|
uint32_t context_after,
|
|
|
|
Stream *s) {
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
// Nothing to write if there's no stream.
|
|
|
|
if (!s)
|
|
|
|
return 0;
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// Sanity check m_data_sp before proceeding.
|
|
|
|
if (!m_data_sp)
|
|
|
|
return 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-08-15 01:12:54 +08:00
|
|
|
size_t bytes_written = s->GetWrittenBytes();
|
|
|
|
|
2018-08-30 08:09:21 +08:00
|
|
|
auto debugger_sp = m_debugger_wp.lock();
|
|
|
|
|
|
|
|
HighlightStyle style;
|
|
|
|
// Use the default Vim style if source highlighting is enabled.
|
|
|
|
if (should_highlight_source(debugger_sp))
|
|
|
|
style = HighlightStyle::MakeVimStyle();
|
|
|
|
|
|
|
|
// If we should mark the stop column with color codes, then copy the prefix
|
|
|
|
// and suffix to our color style.
|
|
|
|
if (should_show_stop_column_with_ansi(debugger_sp))
|
|
|
|
style.selected.Set(debugger_sp->GetStopShowColumnAnsiPrefix(),
|
|
|
|
debugger_sp->GetStopShowColumnAnsiSuffix());
|
2018-08-02 08:30:15 +08:00
|
|
|
|
|
|
|
HighlighterManager mgr;
|
|
|
|
std::string path = GetFileSpec().GetPath(/*denormalize*/ false);
|
|
|
|
// FIXME: Find a way to get the definitive language this file was written in
|
|
|
|
// and pass it to the highlighter.
|
2018-08-30 08:09:21 +08:00
|
|
|
const auto &h = mgr.getHighlighterFor(lldb::eLanguageTypeUnknown, path);
|
2018-08-02 08:30:15 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
const uint32_t start_line =
|
|
|
|
line <= context_before ? 1 : line - context_before;
|
|
|
|
const uint32_t start_line_offset = GetLineOffset(start_line);
|
|
|
|
if (start_line_offset != UINT32_MAX) {
|
|
|
|
const uint32_t end_line = line + context_after;
|
|
|
|
uint32_t end_line_offset = GetLineOffset(end_line + 1);
|
|
|
|
if (end_line_offset == UINT32_MAX)
|
|
|
|
end_line_offset = m_data_sp->GetByteSize();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
assert(start_line_offset <= end_line_offset);
|
|
|
|
if (start_line_offset < end_line_offset) {
|
|
|
|
size_t count = end_line_offset - start_line_offset;
|
|
|
|
const uint8_t *cstr = m_data_sp->GetBytes() + start_line_offset;
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
|
2018-08-02 08:30:15 +08:00
|
|
|
auto ref = llvm::StringRef(reinterpret_cast<const char *>(cstr), count);
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
|
2018-08-30 08:09:21 +08:00
|
|
|
h.Highlight(style, ref, column, "", *s);
|
add stop column highlighting support
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
2016-09-22 04:13:14 +08:00
|
|
|
|
|
|
|
// Ensure we get an end of line character one way or another.
|
2018-08-02 08:30:15 +08:00
|
|
|
if (!is_newline_char(ref.back()))
|
2018-08-15 01:12:54 +08:00
|
|
|
s->EOL();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
}
|
2018-08-15 01:12:54 +08:00
|
|
|
return s->GetWrittenBytes() - bytes_written;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
2011-09-21 09:17:13 +08:00
|
|
|
void SourceManager::File::FindLinesMatchingRegex(
|
|
|
|
RegularExpression ®ex, uint32_t start_line, uint32_t end_line,
|
|
|
|
std::vector<uint32_t> &match_lines) {
|
|
|
|
match_lines.clear();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-09-21 09:17:13 +08:00
|
|
|
if (!LineIsValid(start_line) ||
|
|
|
|
(end_line != UINT32_MAX && !LineIsValid(end_line)))
|
|
|
|
return;
|
|
|
|
if (start_line > end_line)
|
|
|
|
return;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-09-21 09:17:13 +08:00
|
|
|
for (uint32_t line_no = start_line; line_no < end_line; line_no++) {
|
|
|
|
std::string buffer;
|
|
|
|
if (!GetLine(line_no, buffer))
|
|
|
|
break;
|
2016-09-22 00:01:28 +08:00
|
|
|
if (regex.Execute(buffer)) {
|
2011-09-21 09:17:13 +08:00
|
|
|
match_lines.push_back(line_no);
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-09-21 09:17:13 +08:00
|
|
|
}
|
|
|
|
|
2011-09-13 08:29:56 +08:00
|
|
|
bool lldb_private::operator==(const SourceManager::File &lhs,
|
|
|
|
const SourceManager::File &rhs) {
|
2016-11-09 22:04:08 +08:00
|
|
|
if (lhs.m_file_spec != rhs.m_file_spec)
|
2010-06-09 00:52:24 +08:00
|
|
|
return false;
|
2016-11-09 22:04:08 +08:00
|
|
|
return lhs.m_mod_time == rhs.m_mod_time;
|
2011-09-13 08:29:56 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
bool SourceManager::File::CalculateLineOffsets(uint32_t line) {
|
|
|
|
line =
|
|
|
|
UINT32_MAX; // TODO: take this line out when we support partial indexing
|
|
|
|
if (line == UINT32_MAX) {
|
|
|
|
// Already done?
|
|
|
|
if (!m_offsets.empty() && m_offsets[0] == UINT32_MAX)
|
|
|
|
return true;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (m_offsets.empty()) {
|
[lldb] NFC modernize codebase with modernize-use-nullptr
Summary:
NFC = [[ https://llvm.org/docs/Lexicon.html#nfc | Non functional change ]]
This commit is the result of modernizing the LLDB codebase by using
`nullptr` instread of `0` or `NULL`. See
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
for more information.
This is the command I ran and I to fix and format the code base:
```
run-clang-tidy.py \
-header-filter='.*' \
-checks='-*,modernize-use-nullptr' \
-fix ~/dev/llvm-project/lldb/.* \
-format \
-style LLVM \
-p ~/llvm-builds/debug-ninja-gcc
```
NOTE: There were also changes to `llvm/utils/unittest` but I did not
include them because I felt that maybe this library shall be updated in
isolation somehow.
NOTE: I know this is a rather large commit but it is a nobrainer in most
parts.
Reviewers: martong, espindola, shafik, #lldb, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: arsenm, jvesely, nhaehnle, hiraditya, JDevlieghere, teemperor, rnkovacs, emaste, kubamracek, nemanjai, ki.stfu, javed.absar, arichardson, kbarton, jrtc27, MaskRay, atanasyan, dexonsmith, arphaman, jfb, jsji, jdoerfert, lldb-commits, llvm-commits
Tags: #lldb, #llvm
Differential Revision: https://reviews.llvm.org/D61847
llvm-svn: 361484
2019-05-23 19:14:47 +08:00
|
|
|
if (m_data_sp.get() == nullptr)
|
2010-06-09 00:52:24 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
const char *start = (char *)m_data_sp->GetBytes();
|
|
|
|
if (start) {
|
|
|
|
const char *end = start + m_data_sp->GetByteSize();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// Calculate all line offsets from scratch
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// Push a 1 at index zero to indicate the file has been completely
|
|
|
|
// indexed.
|
|
|
|
m_offsets.push_back(UINT32_MAX);
|
2013-08-31 01:50:57 +08:00
|
|
|
const char *s;
|
2010-06-09 00:52:24 +08:00
|
|
|
for (s = start; s < end; ++s) {
|
2013-08-31 01:50:57 +08:00
|
|
|
char curr_ch = *s;
|
2010-06-09 00:52:24 +08:00
|
|
|
if (is_newline_char(curr_ch)) {
|
2013-02-07 11:38:34 +08:00
|
|
|
if (s + 1 < end) {
|
2013-08-31 01:50:57 +08:00
|
|
|
char next_ch = s[1];
|
2013-02-07 11:38:34 +08:00
|
|
|
if (is_newline_char(next_ch)) {
|
|
|
|
if (curr_ch != next_ch)
|
|
|
|
++s;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
m_offsets.push_back(s + 1 - start);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
if (!m_offsets.empty()) {
|
2016-10-06 01:07:34 +08:00
|
|
|
if (m_offsets.back() < size_t(end - start))
|
2015-08-27 07:55:14 +08:00
|
|
|
m_offsets.push_back(end - start);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2011-09-13 08:29:56 +08:00
|
|
|
return true;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Some lines have been populated, start where we last left off
|
2015-08-27 07:55:14 +08:00
|
|
|
assert("Not implemented yet" && false);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
|
|
|
} else {
|
2010-06-09 00:52:24 +08:00
|
|
|
// Calculate all line offsets up to "line"
|
2015-08-27 07:55:14 +08:00
|
|
|
assert("Not implemented yet" && false);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
return false;
|
|
|
|
}
|
2011-09-13 08:29:56 +08:00
|
|
|
|
2011-09-21 09:17:13 +08:00
|
|
|
bool SourceManager::File::GetLine(uint32_t line_no, std::string &buffer) {
|
|
|
|
if (!LineIsValid(line_no))
|
|
|
|
return false;
|
|
|
|
|
2013-01-26 02:06:21 +08:00
|
|
|
size_t start_offset = GetLineOffset(line_no);
|
|
|
|
size_t end_offset = GetLineOffset(line_no + 1);
|
2011-09-21 09:17:13 +08:00
|
|
|
if (end_offset == UINT32_MAX) {
|
|
|
|
end_offset = m_data_sp->GetByteSize();
|
|
|
|
}
|
|
|
|
buffer.assign((char *)m_data_sp->GetBytes() + start_offset,
|
|
|
|
end_offset - start_offset);
|
|
|
|
|
2011-09-13 08:29:56 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SourceManager::SourceFileCache::AddSourceFile(const FileSP &file_sp) {
|
|
|
|
FileSpec file_spec;
|
|
|
|
FileCache::iterator pos = m_file_cache.find(file_spec);
|
|
|
|
if (pos == m_file_cache.end())
|
|
|
|
m_file_cache[file_spec] = file_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
else {
|
2011-09-13 08:29:56 +08:00
|
|
|
if (file_sp != pos->second)
|
|
|
|
m_file_cache[file_spec] = file_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-09-13 08:29:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
SourceManager::FileSP SourceManager::SourceFileCache::FindSourceFile(
|
2010-06-09 00:52:24 +08:00
|
|
|
const FileSpec &file_spec) const {
|
2011-09-13 08:29:56 +08:00
|
|
|
FileSP file_sp;
|
|
|
|
FileCache::const_iterator pos = m_file_cache.find(file_spec);
|
|
|
|
if (pos != m_file_cache.end())
|
|
|
|
file_sp = pos->second;
|
2014-01-28 07:43:24 +08:00
|
|
|
return file_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|