[lldb] Color the line marker

[JDevlieghere]

Summary

Highlight the color marker similar to what we do for the column marker.

[JDevlieghere]

Simplify should_show_stop_line_with_ansi

[clayborg]

If we are going to use this to to ansi stuff we should ensure the suffix works too. The current testing example will turn the line green along with all lines that follow if all other ansi stuff is removed. Right now I am guessing we are getting lucky because something else is doing the ansi reset. Once that is tested, this will be good to go.

lldb/test/Shell/Settings/TestLineMarkerColor.test

5

test suffix?

9

test suffix?

[clayborg]

lldb/source/Core/Debugger.cpp

365

do we have a setting to control how the current line marked? Right now do we hard code it to "->"?

When I stop I see:

(lldb) b main
Breakpoint 1: where = a.out`main + 20 at main.cpp:5:14, address = 0x0000000100000fa4
(lldb) r
Process 1635 launched: '/Users/gclayton/Documents/src/args/a.out' (x86_64)
Process 1635 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000100000fa4 a.out`main(argc=1, argv=0x00007ffeefbff7d0) at main.cpp:5:14
   2   	  return 2*i;
   3   	}
   4   	int main(int argc, const char **argv) {
-> 5   		int i = foo(argc);
   6   		return 0;
   7   	}
   8

Can we make this setting default to "-> " so that the user can change how the current line is marked above and beyond using a color or ansi code?

[JDevlieghere]

Explicitly check the suffix

[JDevlieghere]

lldb/source/Core/Debugger.cpp

365

It's probably doable but I'm not sure if it's worth it:

• This is consistent with the column marker where it doesn't made sense to change the marker because it's just source code.
• Either we need to enforce that the marker is <2 characters or we need to dynamically format everything based on the width, which is complicated by the escape codes.
• You can't change the current PC marker either.

[clayborg]

Ok, we can think about the PC marker later if it wouldn't just work in this setting.

[JDevlieghere]

In D75070#1890334, @clayborg wrote:

Ok, we can think about the PC marker later if it wouldn't just work in this setting.

Yeah, if we change either we should have them both behave the same way

lldb/include/lldb/Core/Debugger.h

public:
   llvm::StringRef GetStopShowColumnAnsiSuffix() const;
 
   uint32_t GetStopSourceLineCount(bool before) const;
 
   StopDisassemblyType GetStopDisassemblyDisplay() const;
 
   uint32_t GetDisassemblyLineCount() const;
 
+  llvm::StringRef GetStopShowLineMarkerAnsiPrefix() const;
+
+  llvm::StringRef GetStopShowLineMarkerAnsiSuffix() const;
+
   bool GetAutoOneLineSummaries() const;
 
   bool GetAutoIndent() const;
 
   bool SetAutoIndent(bool b);
 
   bool GetPrintDecls() const;
 

lldb/source/Core/CoreProperties.td

let Definition = "debugger" in {
   def StopShowColumnAnsiPrefix: Property<"stop-show-column-ansi-prefix", "String">,
     Global,
     DefaultStringValue<"${ansi.underline}">,
     Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the column to be marked.">;
   def StopShowColumnAnsiSuffix: Property<"stop-show-column-ansi-suffix", "String">,
     Global,
     DefaultStringValue<"${ansi.normal}">,
     Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the column to be marked.">;
+  def StopShowLineMarkerAnsiPrefix: Property<"stop-show-line-ansi-prefix", "String">,
+    Global,
+    DefaultStringValue<"${ansi.fg.yellow}">,
+    Desc<"When displaying the line marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the line to be marked.">;
+  def StopShowLineMarkerAnsiSuffix: Property<"stop-show-line-ansi-suffix", "String">,
+    Global,
+    DefaultStringValue<"${ansi.normal}">,
+    Desc<"When displaying the line marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the line to be marked.">;
   def TerminalWidth: Property<"term-width", "SInt64">,
     Global,
     DefaultUnsignedValue<80>,
     Desc<"The maximum number of columns to use for displaying text.">;
   def ThreadFormat: Property<"thread-format", "FormatEntity">,
     Global,
     DefaultStringValue<"thread #${thread.index}: tid = ${thread.id%tid}{, ${frame.pc}}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{, name = ${ansi.fg.green}'${thread.name}'${ansi.normal}}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}{\\\\nCompleted expression: ${thread.completed-expression}}\\\\n">,
     Desc<"The default thread format string to use when displaying thread information.">;

lldb/source/Core/Debugger.cpp

llvm::StringRef Debugger::GetStopShowColumnAnsiPrefix() const {
   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
 }
 
 llvm::StringRef Debugger::GetStopShowColumnAnsiSuffix() const {
   const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
 }
 
+llvm::StringRef Debugger::GetStopShowLineMarkerAnsiPrefix() const {
+  const uint32_t idx = ePropertyStopShowLineMarkerAnsiPrefix;
+  return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
+}
+
+llvm::StringRef Debugger::GetStopShowLineMarkerAnsiSuffix() const {
+  const uint32_t idx = ePropertyStopShowLineMarkerAnsiSuffix;
+  return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
+}
+
 uint32_t Debugger::GetStopSourceLineCount(bool before) const {
   const uint32_t idx =
       before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
   return m_collection_sp->GetPropertyAtIndexAsSInt64(
       nullptr, idx, g_debugger_properties[idx].default_uint_value);
 }
 
 Debugger::StopDisassemblyType Debugger::GetStopDisassemblyDisplay() const {

lldb/source/Core/SourceManager.cpp

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/Twine.h"
static bool should_show_stop_column_with_caret(DebuggerSP debugger_sp) {
   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;
 }
 
+static bool should_show_stop_line_with_ansi(DebuggerSP debugger_sp) {
+  return debugger_sp && debugger_sp->GetUseColor();
+}
+
 size_t SourceManager::DisplaySourceLinesWithLineNumbersUsingLastFile(
     uint32_t start_line, uint32_t count, uint32_t curr_line, uint32_t column,
     const char *current_line_cstr, Stream *s,
     const SymbolContextList *bp_locs) {
   if (count == 0)
     return 0;
 
   Stream::ByteDelta delta(*s);
for (uint32_t line = start_line; line <= end_line; ++line) {
         uint32_t bp_count = bp_locs->NumLineEntriesWithLine(line);
 
         if (bp_count > 0)
           ::snprintf(prefix, sizeof(prefix), "[%u] ", bp_count);
         else
           ::snprintf(prefix, sizeof(prefix), "    ");
       }
 
-      s->Printf("%s%2.2s %-4u\t", prefix,
-                line == curr_line ? current_line_cstr : "", line);
+      char buffer[3];
+      sprintf(buffer, "%2.2s", (line == curr_line) ? current_line_cstr : "");
+      std::string current_line_highlight(buffer);
+
+      auto debugger_sp = m_debugger_wp.lock();
+      if (should_show_stop_line_with_ansi(debugger_sp)) {
+        current_line_highlight = ansi::FormatAnsiTerminalCodes(
+            (debugger_sp->GetStopShowLineMarkerAnsiPrefix() +
+             current_line_highlight +
+             debugger_sp->GetStopShowLineMarkerAnsiSuffix())
+                .str());
+      }
+
+      s->Printf("%s%s %-4u\t", prefix, current_line_highlight.c_str(), line);
 
       // 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);
       if (column != 0 && line == curr_line &&
-          should_show_stop_column_with_caret(m_debugger_wp.lock())) {
+          should_show_stop_column_with_caret(debugger_sp)) {
         // Display caret cursor.
         std::string src_line;
         m_last_file_sp->GetLine(line, src_line);
         s->Printf("    \t");
         // Insert a space for every non-tab character in the source line.
         for (size_t i = 0; i + 1 < column && i < src_line.length(); ++i)
           s->PutChar(src_line[i] == '\t' ? '\t' : ' ');
         // Now add the caret.

lldb/test/API/source-manager/TestSourceManager.py

def do_display_source_python_api(self, use_color, needle_regex, highlight_source=False):
 
         #    2
         #    3    int main(int argc, char const *argv[]) {
         # => 4        printf("Hello world.\n"); // Set break point at this line.
         #    5        return 0;
         #    6    }
         self.expect(stream.GetData(), "Source code displayed correctly:\n" + stream.GetData(),
                     exe=False,
-                    patterns=['=> %d.*Hello world' % self.line,
+                    patterns=['=>', '%d.*Hello world' % self.line,
                               needle_regex])
 
         # Boundary condition testings for SBStream().  LLDB should not crash!
         stream.Print(None)
         stream.RedirectToFile(None, True)
 
     @add_test_categories(['pyapi'])
     def test_display_source_python_dumb_terminal(self):

lldb/test/Shell/Settings/TestLineMarkerColor.test

+# RUN: %clang_host -g -O0 %S/Inputs/main.c -o %t.out
+# RUN: %lldb -x -b -s %s %t.out | FileCheck %s
+settings set use-color true
+settings set stop-show-line-ansi-prefix "prefix"
+settings set stop-show-line-ansi-suffix "suffix"
+b foo
+run
+c
+settings set stop-show-line-ansi-prefix ${ansi.fg.green}
+settings set stop-show-line-ansi-suffix ${ansi.normal}
+run
+q
+
+# Check the ASCII escape code
+# CHECK-NOT: prefix->suffix
+# CHECK: ->
+# CHECK: ␛{{.*}}->{{.*}}␛