[lldb][gui] use left/right in the source view to scroll

[llunak]

Summary

I intentionally decided not to reset the column automatically anywhere, because I don't know where and if at all that should happen. There should be always an indication of being scrolled (too much) to the right, so I'll leave this to whoever has an opinion.

[llunak]

Ping.

[clayborg]

Sorry for the delay! LGTM.

lldb/source/Core/IOHandlerCursesGUI.cpp

public:
   }
 
   size_t LimitLengthToRestOfLine(size_t length) const {
     return std::min<size_t>(length, std::max(0, GetWidth() - GetCursorX() - 1));
   }
 
   // Curses doesn't allow direct output of color escape sequences, but that's
   // how we get source lines from the Highligher class. Read the line and
-  // convert color escape sequences to curses color attributes.
-  void OutputColoredStringTruncated(int right_pad, StringRef string,
+  // convert color escape sequences to curses color attributes. Use
+  // first_skip_count to skip leading visible characters. Returns false if all
+  // visible characters were skipped due to first_skip_count.
+  bool OutputColoredStringTruncated(int right_pad, StringRef string,
+                                    size_t skip_first_count,
                                     bool use_blue_background) {
     attr_t saved_attr;
     short saved_pair;
     int saved_opts;
+    bool result = false;
     ::wattr_get(m_window, &saved_attr, &saved_pair, &saved_opts);
     if (use_blue_background)
       ::wattron(m_window, COLOR_PAIR(WhiteOnBlue));
     while (!string.empty()) {
       size_t esc_pos = string.find('\x1b');
       if (esc_pos == StringRef::npos) {
+        string = string.substr(skip_first_count);
+        if (!string.empty()) {
           PutCStringTruncated(right_pad, string.data(), string.size());
+          result = true;
+        }
         break;
       }
       if (esc_pos > 0) {
+        if (skip_first_count > 0) {
+          int skip = std::min(esc_pos, skip_first_count);
+          string = string.substr(skip);
+          skip_first_count -= skip;
+          esc_pos -= skip;
+        }
+        if (esc_pos > 0) {
           PutCStringTruncated(right_pad, string.data(), esc_pos);
+          result = true;
           string = string.drop_front(esc_pos);
         }
+      }
       bool consumed = string.consume_front("\x1b");
       assert(consumed);
       UNUSED_IF_ASSERT_DISABLED(consumed);
       // This is written to match our Highlighter classes, which seem to
       // generate only foreground color escape sequences. If necessary, this
       // will need to be extended.
       if (!string.consume_front("[")) {
         llvm::errs() << "Missing '[' in color escape sequence.\n";
while (!string.empty()) {
           ::wattron(m_window, COLOR_PAIR(WhiteOnBlue));
       } else {
         // Mapped directly to first 16 color pairs (black/blue background).
         ::wattron(m_window,
                   COLOR_PAIR(value - 30 + 1 + (use_blue_background ? 8 : 0)));
       }
     }
     ::wattr_set(m_window, saved_attr, saved_pair, &saved_opts);
+    return result;
   }
 
   void Touch() {
     ::touchwin(m_window);
     if (m_parent)
       m_parent->Touch();
   }
 

 
 class SourceFileWindowDelegate : public WindowDelegate {
 public:
   SourceFileWindowDelegate(Debugger &debugger)
       : WindowDelegate(), m_debugger(debugger), m_sc(), m_file_sp(),
         m_disassembly_scope(nullptr), m_disassembly_sp(), m_disassembly_range(),
         m_title(), m_line_width(4), m_selected_line(0), m_pc_line(0),
         m_stop_id(0), m_frame_idx(UINT32_MAX), m_first_visible_line(0),
-        m_min_x(0), m_min_y(0), m_max_x(0), m_max_y(0) {}
+        m_first_visible_column(0), m_min_x(0), m_min_y(0), m_max_x(0),
+        m_max_y(0) {}
 
   ~SourceFileWindowDelegate() override = default;
 
   void Update(const SymbolContext &sc) { m_sc = sc; }
 
   uint32_t NumVisibleLines() const { return m_max_y - m_min_y; }
 
   const char *WindowDelegateGetHelpText() override {
     return "Source/Disassembly window keyboard shortcuts:";
   }
 
   KeyHelp *WindowDelegateGetKeyHelp() override {
     static curses::KeyHelp g_source_view_key_help[] = {
         {KEY_RETURN, "Run to selected line with one shot breakpoint"},
         {KEY_UP, "Select previous source line"},
         {KEY_DOWN, "Select next source line"},
+        {KEY_LEFT, "Scroll to the left"},
+        {KEY_RIGHT, "Scroll to the right"},
         {KEY_PPAGE, "Page up"},
         {KEY_NPAGE, "Page down"},
         {'b', "Set breakpoint on selected source/disassembly line"},
         {'c', "Continue process"},
         {'D', "Detach with process suspended"},
         {'h', "Show help dialog"},
         {'n', "Step over (source line)"},
         {'N', "Step over (single instruction)"},
if (num_source_lines > 0) {
           if (highlight_attr)
             window.AttributeOn(highlight_attr);
 
           StreamString lineStream;
           m_file_sp->DisplaySourceLines(curr_line + 1, {}, 0, 0, &lineStream);
           StringRef line = lineStream.GetString();
           if (line.endswith("\n"))
             line = line.drop_back();
-          window.OutputColoredStringTruncated(1, line, line_is_selected);
-          if (line_is_selected && line.empty()) {
-            // Draw an empty space to show the selected line.
+          bool wasWritten = window.OutputColoredStringTruncated(
+              1, line, m_first_visible_column, line_is_selected);
+          if (line_is_selected && !wasWritten) {
+            // Draw an empty space to show the selected line if empty,
+            // or draw '<' if nothing is visible because of scrolling too much
+            // to the right.
             const attr_t selected_attr = COLOR_PAIR(WhiteOnBlue);
             window.AttributeOn(selected_attr);
-            window.PutCStringTruncated(1, " ");
+            window.PutCStringTruncated(
+                1, line.empty() && m_first_visible_column == 0 ? " " : "<");
             window.AttributeOff(selected_attr);
           }
 
           if (is_pc_line && frame_sp &&
               frame_sp->GetConcreteFrameIndex() == 0) {
             StopInfoSP stop_info_sp;
             if (thread)
               stop_info_sp = thread->GetStopInfo();
if (num_source_lines > 0) {
           if (mnemonic != nullptr && operands != nullptr && comment != nullptr)
             strm.Printf("%-8s %-25s ; %s", mnemonic, operands, comment);
           else if (mnemonic != nullptr && operands != nullptr)
             strm.Printf("%-8s %s", mnemonic, operands);
           else if (mnemonic != nullptr)
             strm.Printf("%s", mnemonic);
 
           int right_pad = 1;
-          window.PutCStringTruncated(right_pad, strm.GetData());
+          window.PutCStringTruncated(
+              right_pad,
+              strm.GetString().substr(m_first_visible_column).data());
 
           if (is_pc_line && frame_sp &&
               frame_sp->GetConcreteFrameIndex() == 0) {
             StopInfoSP stop_info_sp;
             if (thread)
               stop_info_sp = thread->GetStopInfo();
             if (stop_info_sp) {
               const char *stop_description = stop_info_sp->GetDescription();
HandleCharResult WindowDelegateHandleChar(Window &window, int c) override {
     case KEY_DOWN:
       if (m_selected_line + 1 < num_lines) {
         m_selected_line++;
         if (m_first_visible_line + num_visible_lines < m_selected_line)
           m_first_visible_line++;
       }
       return eKeyHandled;
 
+    case KEY_LEFT:
+      if (m_first_visible_column > 0)
+        --m_first_visible_column;
+      return eKeyHandled;
+
+    case KEY_RIGHT:
+      ++m_first_visible_column;
+      return eKeyHandled;
+
     case '\r':
     case '\n':
     case KEY_ENTER:
       // Set a breakpoint and run to the line using a one shot breakpoint
       if (GetNumSourceLines() > 0) {
         ExecutionContext exe_ctx =
             m_debugger.GetCommandInterpreter().GetExecutionContext();
         if (exe_ctx.HasProcessScope() && exe_ctx.GetProcessRef().IsAlive()) {
protected:
   StreamString m_title;
   lldb::user_id_t m_tid;
   int m_line_width;
   uint32_t m_selected_line; // The selected line
   uint32_t m_pc_line;       // The line with the PC
   uint32_t m_stop_id;
   uint32_t m_frame_idx;
   int m_first_visible_line;
+  int m_first_visible_column;
   int m_min_x;
   int m_min_y;
   int m_max_x;
   int m_max_y;
 };
 
 DisplayOptions ValueObjectListDelegate::g_options = {true};
 

lldb/test/API/commands/gui/viewlarge/TestGuiViewLarge.py

def test_gui(self):
         self.build()
 
         # Limit columns to 80, so that long lines will not be displayed completely.
         self.launch(executable=self.getBuildArtifact("a.out"), dimensions=(100,80))
         self.expect('br set -f main.c -p "// Break here"', substrs=["Breakpoint 1", "address ="])
         self.expect("run", substrs=["stop reason ="])
 
         escape_key = chr(27).encode()
+        left_key = chr(27)+'OD' # for vt100 terminal (lldbexpect sets TERM=vt100)
+        right_key = chr(27)+'OC'
+        ctrl_l = chr(12)
 
         # Start the GUI.
         self.child.sendline("gui")
 
         # Check the sources window.
         self.child.expect_exact("Sources")
         # The string is copy&pasted from a 80-columns terminal. It will be followed by some
         # kind of an escape sequence (color, frame, etc.).
         self.child.expect_exact("int a_variable_with_a_very_looooooooooooooooooooooooooo"+chr(27))
         # The escape here checks that there's no content drawn by the previous line.
         self.child.expect_exact("int shortvar = 1;"+chr(27))
         # Check the triggered breakpoint marker on a long line.
         self.child.expect_exact("<<< Thread 1: breakpoint 1.1"+chr(27))
 
         # Check the variable window.
         self.child.expect_exact("Variables")
         self.child.expect_exact("(int) a_variable_with_a_very_looooooooooooooooooooooooooooooo"+chr(27))
         self.child.expect_exact("(int) shortvar = 1"+chr(27))
 
+        # Scroll the sources view twice to the right.
+        self.child.send(right_key)
+        self.child.send(right_key)
+        # Force a redraw, otherwise curses will optimize the drawing to not draw all 'o'.
+        self.child.send(ctrl_l)
+        # The source code is indented by two spaces, so there'll be just two extra 'o' on the right.
+        self.child.expect_exact("int a_variable_with_a_very_looooooooooooooooooooooooooooo"+chr(27))
+
+        # And scroll back to the left.
+        self.child.send(left_key)
+        self.child.send(left_key)
+        self.child.send(ctrl_l)
+        self.child.expect_exact("int a_variable_with_a_very_looooooooooooooooooooooooooo"+chr(27))
+
         # Press escape to quit the gui
         self.child.send(escape_key)
 
         self.expect_prompt()
         self.quit()