Merge pull request #1880 from contour-terminal/fix/tab-characters-lost

Fix tab characters (HT) intermittently lost in output

Author: christianparpart

.github/actions/spelling/allow/allow.txt

@@ -7,11 +7,13 @@ Dbus
 ENDCHAR
 ENDFONT
 ENDPROPERTIES
+FFFFFFFF
 FONTBOUNDINGBOX
 FreeBSD
 LASTEXITCODE
 OPENCONSOLE
 OpenBSD
+RTX
 SEMA
 STARTCHAR
 STARTFONT
@@ -32,6 +34,7 @@ copy'n'paste
 copyable
 crossfade
 dbus
+flamegraphs
 gha
 ilammy
 lazygit
@@ -55,4 +58,5 @@ tparam
 unk
 urg
 vswhere
+winget
 zypper

metainfo.xml

@@ -119,6 +119,7 @@
           <li>Fixes ~2s startup delay caused by synchronous Qt multimedia driver probing by deferring audio initialization to a background thread</li>
           <li>Fixes initial font sizing at fractional DPR on Wayland by preferring screen DPR over window DPR</li>
           <li>Fixes Kitty keyboard protocol: proper CapsLock/NumLock modifier reporting, correct modifier encoding per spec, and Unicode case folding for non-ASCII characters</li>
+          <li>Fixes tab characters (HT) intermittently lost in terminal output due to bulk text parser skipping trailing C0 controls and tab cursor movement not filling intermediate cells with spaces (#1876)</li>
           <li>Replaces abrupt cell blink toggle with configurable smooth pulse animation via blink_style profile setting (classic/smooth/linger)</li>
           <li>Adds configurable crossfade transition between primary and alternate screens via screen_transition and screen_transition_duration profile settings</li>
           <li>Adds animated cursor movement between grid cells with ease-out interpolation via cursor_motion_animation_duration profile setting</li>

src/vtbackend/Screen.cpp

@@ -1621,6 +1621,9 @@ void Screen<Cell>::moveCursorToNextTab()
     // TODO: respect HTS/TBC
 
     static_assert(TabWidth > ColumnCount(0));
+
+    auto columnsToAdvance = ColumnCount(0);
+
     if (!_terminal->tabs().empty())
     {
         // advance to the next tab
@@ -1631,21 +1634,33 @@ void Screen<Cell>::moveCursorToNextTab()
         auto const currentCursorColumn = logicalCursorPosition().column;
 
         if (i < _terminal->tabs().size())
-            moveCursorForward(boxed_cast<ColumnCount>(_terminal->tabs()[i] - currentCursorColumn));
+            columnsToAdvance = boxed_cast<ColumnCount>(_terminal->tabs()[i] - currentCursorColumn);
         else if (realCursorPosition().column < margin().horizontal.to)
-            moveCursorForward(boxed_cast<ColumnCount>(margin().horizontal.to - currentCursorColumn));
+            columnsToAdvance = boxed_cast<ColumnCount>(margin().horizontal.to - currentCursorColumn);
     }
     else
     {
         // default tab settings
         if (realCursorPosition().column < margin().horizontal.to)
         {
-            auto const n =
+            columnsToAdvance =
                 std::min((TabWidth - boxed_cast<ColumnCount>(_cursor.position.column) % TabWidth),
                          pageSize().columns - boxed_cast<ColumnCount>(logicalCursorPosition().column));
-            moveCursorForward(n);
         }
     }
+
+    if (columnsToAdvance > ColumnCount(0))
+    {
+        // Fill intermediate cells with spaces to ensure TrivialLineBuffer consistency.
+        // Without this, the cursor advances but the cell buffer doesn't reflect the gap,
+        // causing tabs to be visually lost during rendering.
+        auto const startCol = _cursor.position.column;
+        auto& line = currentLine();
+        for (auto const i: std::views::iota(0, unbox(columnsToAdvance)))
+            line.useCellAt(startCol + ColumnOffset(i)).write(_cursor.graphicsRendition, L' ', 1);
+
+        moveCursorForward(columnsToAdvance);
+    }
 }
 
 template <CellConcept Cell>
@@ -3305,6 +3320,11 @@ template <CellConcept Cell>
 void Screen<Cell>::executeControlCode(char controlCode)
 {
 #if defined(LIBTERMINAL_LOG_TRACE)
+    // Flush any pending text trace before processing the control code.
+    // Without this, when the parser's bulk text optimization processes
+    // text → C0 → text inline (without leaving Ground state), writeTextEnd()
+    // is never called, causing gaps in the trace log.
+    writeTextEnd();
     if (vtTraceSequenceLog)
         vtTraceSequenceLog()(
             "control U+{:02X} ({})", controlCode, to_string(static_cast<ControlCode::C0>(controlCode)));

src/vtbackend/Screen_test.cpp

@@ -3978,6 +3978,78 @@ TEST_CASE("LS1 and LS0", "[screen]")
 // TODO: SendDeviceAttributes
 // TODO: SendTerminalId
 
+TEST_CASE("HorizontalTab.FillsCellsWithSpaces", "[screen]")
+{
+    // Verify that HT fills intermediate cells with space characters,
+    // not just moves the cursor. This ensures TrivialLineBuffer consistency.
+    auto mock = MockTerm { PageSize { LineCount(2), ColumnCount(20) } };
+    auto& screen = mock.terminal.primaryScreen();
+
+    mock.writeToScreen("A\tB");
+
+    // 'A' at col 0, tab advances to col 8 (default tab width), 'B' at col 8.
+    // Columns 1..7 should be filled with spaces, rendering correctly.
+    CHECK(screen.logicalCursorPosition().column == ColumnOffset(9));
+    CHECK("A       B           \n                    \n" == screen.renderMainPageText());
+}
+
+TEST_CASE("HorizontalTab.AfterBulkText", "[screen]")
+{
+    // Write printable ASCII followed by HT followed by more text.
+    // This exercises the parseBulkText fast-path → C0 execute → more text path.
+    auto mock = MockTerm { PageSize { LineCount(2), ColumnCount(20) } };
+    auto& screen = mock.terminal.primaryScreen();
+
+    mock.writeToScreen("AB\tCD");
+
+    // "AB" occupies columns 0-1, tab advances to column 8, "CD" at columns 8-9
+    CHECK("AB      CD          \n                    \n" == screen.renderMainPageText());
+    CHECK(screen.logicalCursorPosition().column == ColumnOffset(10));
+}
+
+TEST_CASE("HorizontalTab.MultipleTabs", "[screen]")
+{
+    // "A\tB\tC" should produce correctly spaced output with space-filled cells.
+    auto mock = MockTerm { PageSize { LineCount(2), ColumnCount(25) } };
+    auto& screen = mock.terminal.primaryScreen();
+
+    mock.writeToScreen("A\tB\tC");
+
+    // 'A' at col 0, tab to col 8, 'B' at col 8, tab to col 16, 'C' at col 16
+    CHECK("A       B       C        \n                         \n" == screen.renderMainPageText());
+    CHECK(screen.logicalCursorPosition().column == ColumnOffset(17));
+}
+
+TEST_CASE("HorizontalTab.AtChunkBoundary", "[screen]")
+{
+    // Force text+tab across chunk boundaries by using a small ptyReadBufferSize.
+    // The tab character should still be processed correctly even at a chunk boundary.
+    auto mock = MockTerm { PageSize { LineCount(2), ColumnCount(20) }, LineCount(0), 4 };
+    auto& screen = mock.terminal.primaryScreen();
+
+    mock.writeToScreen("ABC\tD");
+
+    // "ABC" at cols 0-2, tab to col 8, 'D' at col 8
+    CHECK("ABC     D           \n                    \n" == screen.renderMainPageText());
+}
+
+TEST_CASE("HorizontalTab.AfterScreenClear", "[screen]")
+{
+    // After ED (Erase in Display), write text with tabs and verify correct rendering.
+    // This tests TrivialLineBuffer reset + tab interaction.
+    auto mock = MockTerm { PageSize { LineCount(2), ColumnCount(20) } };
+    auto& screen = mock.terminal.primaryScreen();
+
+    // Write initial content
+    mock.writeToScreen("Hello World");
+    // Clear screen (CSI 2 J) and cursor home (CSI H)
+    mock.writeToScreen("\033[2J\033[H");
+    // Write text with tab
+    mock.writeToScreen("X\tY");
+
+    CHECK("X       Y           \n                    \n" == screen.renderMainPageText());
+}
+
 // NOLINTEND(misc-const-correctness,readability-function-cognitive-complexity)
 
 // NOLINTBEGIN(misc-const-correctness)

src/vtparser/Parser-impl.h

@@ -474,13 +474,28 @@ auto Parser<EventListener, TraceStateChanges>::parseBulkText(char const* begin,
 
     if (_scanState.utf8.expectedLength == 0)
     {
-        // This optimization is for the `cat`-people.
-        // It further optimizes the throughput performance by bypassing
-        // the FSM for the `(TEXT LF+)+`-case.
+        // Process trailing C0 control characters inline, bypassing the FSM.
+        // This handles the common (TEXT C0)+ pattern (e.g. text followed by LF, HT, CR)
+        // with a significant throughput improvement (~50x for cat-like workloads).
         //
-        // As of bench-headless, the performance increase is about 50x.
-        if (input != end && *input == '\n')
-            _eventListener.execute(*input++);
+        // C0 Execute range: 0x00-0x17, 0x19, 0x1C-0x1F (bits in a 32-bit mask)
+        // Excluded: 0x18 (CAN) and 0x1A (SUB) — trigger state transitions (Ground + Ignore)
+        // Excluded: 0x1B (ESC) — transitions to Escape state
+        constexpr auto C0ExecuteMask =
+            uint32_t { 0xFFFFFFFF } & ~(1u << 0x18) & ~(1u << 0x1A) & ~(1u << 0x1B);
+        auto const* current = _scanState.next;
+        while (current != end)
+        {
+            auto const ch = static_cast<uint8_t>(*current);
+            if (ch < 0x20 && (C0ExecuteMask & (1u << ch)) != 0)
+            {
+                _eventListener.execute(*current);
+                ++current;
+            }
+            else
+                break;
+        }
+        _scanState.next = current;
     }
 
     auto const count = static_cast<size_t>(std::distance(input, _scanState.next));