rubyterm 0.1.0

data/lib/termbuffer.rb

@@ -0,0 +1,365 @@
+require 'set'
+
+  BOLD          = 0x002
+  FAINT         = 0x004
+  ITALICS       = 0x008
+  UNDERLINE     = 0x010
+  BLINK         = 0x020
+  RAPID_BLINK   = 0x040
+  INVERSE       = 0x080
+  INVISIBLE     = 0x100
+  CROSSED_OUT   = 0x200
+  DBL_UNDERLINE = 0x400
+  OVERLINE      = 0x800
+
+# The screen buffer: a grid of styled cells + scrollback + scroll region.
+#
+# Storage is COLUMNAR. A row is not an array of [ch,fg,bg,flags] cell
+# objects; it is split across three parallel arrays of tagged immediates,
+# held per row:
+#
+#   @chars[y][x] - codepoint Integer (nil = unset/blank cell)
+#   @style[y][x] - packed Integer: fg(24) | bg(24)<<24 | flags<<48
+#   @gen[y][x]   - per-cell generation Integer (the damage primitive)
+#
+# Integers in the fixnum range and nil are stored in the VALUE word with no
+# heap allocation, so writing a cell allocates nothing (vs. an Array per
+# glyph before). fg/bg are 24-bit and flags < 2^12, so a cell's attributes
+# pack into one fixnum. See docs/architecture-review.md §8.
+#
+# @gen is a monotonic per-cell version, bumped only when a cell's content
+# actually changes. It is the damage primitive a backend consumes to know
+# which cells to repaint; the harness's markers check reads it too
+# (generation_at), but it is genuine production state, not debug-only
+# weight. Because @gen is stored and moved alongside @chars/@style, the
+# generation follows a cell through scrolls and line/char insert+delete for
+# free - no separate bookkeeping.
+#
+# Scrollback lines reuse the exact columnar representation: a scrolled-off
+# line is the pair [chars_row, style_row], moved straight into history (no
+# per-cell objects, ~40x fewer retained objects than the old form).
+class TermBuffer
+  attr_accessor :scroll_start, :scroll_end
+  attr_reader :w, :scrollback_buffer, :scrollback_lineattrs, :generation
+
+  def initialize
+    @w = nil
+    @h = nil
+    @generation = 0
+    clear
+    @scroll_start = nil
+    @scroll_end = nil
+  end
+
+  def clear
+    @chars     = []
+    @style     = []
+    @gen       = []
+    @lineattrs = []
+    @scrollback_buffer = []
+    @scrollback_lineattrs = []
+    @blinky = Set.new
+    @row_dirty = [] # rows changed since the last each_damaged walk
+    # NB: @generation is deliberately NOT reset - it stays monotonic across
+    # clears so a redrawn-after-clear cell never collides with a stale gen.
+  end
+
+  def scrollback_size = @scrollback_buffer.size
+  def blinky          = @blinky
+
+  def on_resize(w, h)
+    raise if !h
+    @w, @h = w, h
+    enforce_height
+  end
+  alias resize on_resize
+
+  # # Packing helpers
+
+  def pack_style(fg, bg, flags)
+    (fg.to_i & 0xFFFFFF) | ((bg.to_i & 0xFFFFFF) << 24) | (flags.to_i << 48)
+  end
+
+  def cell(ch, style)
+    [ch, style & 0xFFFFFF, (style >> 24) & 0xFFFFFF, style >> 48]
+  end
+
+  # Reconstruct a [chars, styles] scrollback pair into an array of cells.
+  def unpack_line(packed)
+    chars, styles = packed
+    chars.map.with_index { |ch, x| ch && cell(ch, styles[x]) }
+  end
+
+  private def ensure_row(y)
+    @chars[y]     ||= []
+    @style[y]     ||= []
+    @gen[y]       ||= []
+    @lineattrs[y] ||= 0
+  end
+
+  # Rebuild row y as an array of cells (nil for unset positions), or nil if
+  # the row has never been written. Non-mutating.
+  private def reconstruct_row(y)
+    chars = @chars[y] or return nil
+    styles = @style[y]
+    chars.map.with_index { |ch, x| ch && cell(ch, styles[x]) }
+  end
+
+  # # Reads
+
+  def get(x, y)
+    if y < 0
+      row = line_at(y)
+      return row && row[x]
+    end
+    chars = @chars[y] or return nil
+    ch = chars[x] or return nil
+    cell(ch, @style[y][x])
+  end
+
+  # Whole row of cells. Negative rows come from scrollback.
+  def getline(y)
+    return line_at(y) if y < 0
+    reconstruct_row(y) || []
+  end
+
+  # Like #getline but non-vivifying and nil (not []) for an absent row, and
+  # mapping negative rows into the (unpacked) scrollback. Safe for read-only
+  # traversal such as selection extraction across scrollback.
+  def line_at(y)
+    if y < 0 && !@scrollback_buffer.empty?
+      i = @scrollback_buffer.size + y
+      return i >= 0 ? unpack_line(@scrollback_buffer[i]) : nil
+    end
+    reconstruct_row(y)
+  end
+
+  def lineattrs(y)
+    y = y.to_i
+    if y < 0 && !@scrollback_lineattrs.empty?
+      i = @scrollback_lineattrs.size + y
+      return i >= 0 ? @scrollback_lineattrs[i] : 0
+    end
+    @lineattrs[y]
+  end
+
+  # The damage primitive: the generation at which (x,y) last changed, or
+  # nil for an unset cell. Scrollback is not damage-tracked.
+  def generation_at(x, y)
+    return nil if y < 0
+    g = @gen[y] and g[x]
+  end
+
+  # Yield [x, y, ch, fg, bg, flags] for every cell whose content changed
+  # after +since_gen+ - the damage since the last flush - as scalars, no
+  # cell Array allocated. A damage-driven renderer walks this instead of
+  # being told to draw eagerly on every #set. Returns the current
+  # generation so the caller can advance its watermark. (Walks all rows;
+  # row-level dirty tracking is a later optimisation.)
+  def each_damaged(since_gen)
+    @row_dirty.each_index do |y|
+      next unless @row_dirty[y]
+      @row_dirty[y] = false
+      gens = @gen[y] or next
+      chars = @chars[y]
+      styles = @style[y]
+      gens.each_index do |x|
+        g = gens[x]
+        next if !g || g <= since_gen
+        ch = chars[x] or next
+        s = styles[x]
+        yield x, y, ch, s & 0xFFFFFF, (s >> 24) & 0xFFFFFF, s >> 48
+      end
+    end
+    @generation
+  end
+
+  # True if (x,y) currently holds exactly this content. Lets the draw path
+  # skip identical repaints without reconstructing a cell Array (the prior
+  # `new == get(x,y)` allocated one per character).
+  def cell_eq?(x, y, ch, fg, bg, flags)
+    chars = @chars[y] or return false
+    chars[x] == ch && @style[y][x] == pack_style(fg, bg, flags)
+  end
+
+  # True if (x,y) has never been written (blank).
+  def unset?(x, y)
+    chars = @chars[y]
+    !chars || chars[x].nil?
+  end
+
+  # Yields [x, y, cell] for every *set* cell, scrollback (if offset>0) first
+  # at the top, then the live grid below it.
+  def each_character(scrollback_offset = 0)
+    used = 0
+    if scrollback_offset > 0 && !@scrollback_buffer.empty?
+      offset = [@scrollback_buffer.size, scrollback_offset].min
+      if offset > 0
+        lines = @scrollback_buffer[-offset..-1] || []
+        lines.each_with_index do |packed, idx|
+          chars, styles = packed
+          chars.each_with_index do |ch, x|
+            yield x, idx, cell(ch, styles[x]) if ch
+          end
+        end
+        used = lines.size
+      end
+    end
+
+    # +1 mirrors the historical off-by-one (draw one extra row).
+    remaining = @h ? (@h - used + 1) : @chars.size
+    @chars.each_with_index do |chars, y|
+      next if !chars || y >= remaining
+      styles = @style[y]
+      chars.each_with_index do |ch, x|
+        yield x, y + used, cell(ch, styles[x]) if ch
+      end
+    end
+  end
+
+  def each_character_between(spos, epos)
+    if spos.end > epos.end
+      spos, epos = epos, spos
+    elsif spos.end == epos.end && spos.first > epos.first
+      spos, epos = epos, spos
+    end
+
+    x = spos.first
+    xend, ymax = epos.first, epos.end
+    (spos.end..ymax).each do |y|
+      line = line_at(y) || ""
+      xmax = y == ymax ? xend + 1 : line.length - 1
+      xmax = [xmax, line.length - 1].min
+      xmax = 0 if xmax < 0
+      while x <= xmax
+        yield(x, y, line[x])
+        x += 1
+      end
+      x = 0
+    end
+  end
+
+  # # Writes
+
+  def set(x, y, ch, fg = 0, bg = 0, flags = 0)
+    ch = ch.ord
+    if flags.anybits?(BLINK | RAPID_BLINK)
+      @blinky << [x, y]
+    elsif !@blinky.empty?
+      # Only bother removing (and allocating the [x,y] key) when something
+      # actually blinks. The overwhelmingly common case is no blinking cells
+      # at all, so this skips a per-character array alloc + Set#delete.
+      @blinky.delete([x, y])
+    end
+    ensure_row(y)
+    style = pack_style(fg, bg, flags)
+    # Bump the generation only on an actual content change (identical
+    # rewrites keep their gen, so a cell that didn't change isn't seen as
+    # damaged).
+    if @chars[y][x] != ch || @style[y][x] != style
+      @gen[y][x] = (@generation += 1)
+      @row_dirty[y] = true
+    end
+    @chars[y][x] = ch
+    @style[y][x] = style
+  end
+
+  def set_lineattrs(y, v) = (@lineattrs[y] = v)
+
+  # ICH / IRM: open a gap of +num+ cells at x by inserting +cell+, shifting
+  # the rest of the line right; cells pushed past the right margin are
+  # discarded (the line never grows beyond width). Inserted cells carry no
+  # generation (they did not go through #set); they are blanks the caller
+  # repaints.
+  def insert(x, y, num, cell)
+    ensure_row(y)
+    ch = cell[0]
+    style = pack_style(cell[1], cell[2], cell[3])
+    num.times do
+      @chars[y].insert(x, ch)
+      @style[y].insert(x, style)
+      @gen[y].insert(x, nil)
+    end
+    if @w && @chars[y].length > @w
+      @chars[y].slice!(@w..)
+      @style[y].slice!(@w..)
+      @gen[y].slice!(@w..)
+    end
+  end
+
+  # DCH: delete +num+ cells at (x,y), shifting the remainder left (gens
+  # follow their cells). Vacated cells at the right become blank.
+  def delete_chars(x, y, num)
+    chars = @chars[y] or return
+    num.times do
+      break if x >= chars.length
+      chars.delete_at(x)
+      @style[y].delete_at(x)
+      @gen[y].delete_at(x)
+    end
+  end
+
+  def clear_line(y, start_x = 0, end_x = nil)
+    if !end_x
+      # Clear to end of line: truncate the row at start_x. Dropped cells
+      # become unset (gen nil), so a stale on-screen tail is detectable.
+      if @chars[y]
+        @chars[y] = @chars[y][0...start_x]
+        @style[y] = (@style[y] || [])[0...start_x]
+        @gen[y]   = (@gen[y]   || [])[0...start_x]
+      end
+    else
+      (start_x..end_x).each { |x| set(x, y, ' ') }
+    end
+  end
+
+  # # Line operations (region-aware)
+
+  private def raw_delete_line(y)
+    @chars.slice!(y)
+    @style.slice!(y)
+    @gen.slice!(y)
+    @lineattrs.slice!(y)
+  end
+
+  private def raw_insert_line(y)
+    @chars.insert(y, nil)
+    @style.insert(y, nil)
+    @gen.insert(y, nil)
+    @lineattrs.insert(y, 0)
+    enforce_height
+  end
+
+  def delete_line(y)
+    raw_delete_line(y)
+    # In a scroll region, deleting a line shifts the region up and inserts a
+    # blank line at the bottom (scroll_end), not at the top.
+    raw_insert_line(@scroll_end) if @scroll_start
+  end
+
+  def insert_line(y)
+    raw_insert_line(y)
+    # Inserting pushes the region down; discard the line that falls just
+    # past the bottom of the region.
+    raw_delete_line(@scroll_end + 1) if @scroll_end
+  end
+
+  def scroll_up
+    # Move the top line of the region into scrollback - the columnar
+    # [chars, style] arrays ARE the packed scrollback form, so this is a
+    # straight handoff (delete_line then drops the live references). The
+    # gen row is discarded (scrollback is not damage-tracked).
+    y = @scroll_start.to_i
+    @scrollback_buffer.push([@chars[y] || [], @style[y] || []])
+    @scrollback_lineattrs.push(lineattrs(y))
+    delete_line(y)
+  end
+
+  def enforce_height
+    return unless @h
+    @chars.slice!(@h..)
+    @style.slice!(@h..)
+    @gen.slice!(@h..)
+    @lineattrs.slice!(@h..)
+  end
+end

data/lib/trackchanges.rb

@@ -0,0 +1,319 @@
+
+# FIXME: Roll this into the actual buffer.
+class TrackChanges
+  # The cursor is rendered as an overlay - a cell repainted with this
+  # background. The AnsiBackend recognises it and turns it into a real
+  # terminal cursor; the X11 backend paints the block.
+  CURSOR = 0xff00ff
+
+  def initialize buffer, adapter
+    @buffer = buffer
+    @adapter = adapter
+    @cursor_pos = nil   # where the cursor overlay was last painted
+    # When true, #set only mutates the buffer; rendering is deferred to the
+    # next #draw_flush, which walks the buffer's damage (generation) instead
+    # of drawing eagerly per cell. Default off (the proven eager path) while
+    # the damage-driven path is validated against it; see test_damage.rb.
+    @defer = false
+    @last_flush_gen = 0
+    @rows = 24      # overwritten by on_resize before use
+    # When true, ALL rendering is suppressed (the buffer still mutates):
+    # used to jump-scroll a flood of output by interpreting many chunks and
+    # then doing ONE full redraw of the final screen, skipping the
+    # intermediate frames the user would never see. The model (incl.
+    # scrollback) stays correct; only the framebuffer is batched.
+    @suspend = false
+    clear
+  end
+
+  attr_reader :buffer
+  attr_accessor :defer, :suspend
+
+  # Rendering is off either because we're viewing scrollback history or
+  # because output is being jump-scrolled.
+  def suppressed? = @suspend || @adapter.scrollback_mode
+
+  def clear
+    # Flush any batched text first: otherwise pending draws are emitted to
+    # the screen AFTER the clear and survive it (stale content; the buffer
+    # is already correct, so only the incremental render diverges).
+    draw_flush
+    @buffer.clear
+    @adapter.clear unless suppressed?
+  end
+
+  # Methods that does not alter the buffer
+  def lineattrs(y)  = @buffer.lineattrs(y)
+  def get(x,y)      = @buffer.get(x,y)
+  def scroll_start  = @buffer.scroll_start
+  def scroll_end    = @buffer.scroll_end
+  def blinky        = @buffer.blinky
+  # Backend-facing queries the interpreter routes through the buffer rather
+  # than reaching the adapter directly (so Term talks only to its buffer).
+  def scrollback_mode = @adapter.scrollback_mode
+  def set_columns(cols) = @adapter.set_columns(cols)
+  def each_character(scrollback_offset = 0, &block)
+    @buffer.each_character(scrollback_offset, &block)
+  end
+
+  # # Mutation
+  #
+  # Scroll the region up one line: draw pending damage, scroll the model,
+  # then drive the backend - a blit, or (when scrolled back) just anchor the
+  # viewport so the frozen history lines stay in place. The blit's inclusive
+  # bottom row is the scroll region's, or the last screen row when unset.
+  def scroll_up
+    draw_flush
+    start  = @buffer.scroll_start.to_i
+    bottom = @buffer.scroll_end || (@rows - 1)
+    @buffer.scroll_up
+    return if @suspend
+    if @adapter.scrollback_mode
+      @adapter.scrollback_anchor
+    else
+      @adapter.scroll_up(start, bottom)
+    end
+  end
+
+  def delete_lines(y, num, maxy)
+    draw_flush
+    # Delete repeatedly at the SAME row: each delete shifts the rows below
+    # up into y, so deleting at y+i would skip every other line.
+    num.times { @buffer.delete_line(y) }
+    @adapter.delete_lines(y, num, @buffer.scroll_end||maxy) unless suppressed?
+  end
+
+  def insert_lines(y, num, maxy)
+    draw_flush
+    num.times.each {|i| @buffer.insert_line(y+i) }
+    @adapter.insert_lines(y, num, @buffer.scroll_end || maxy) unless suppressed?
+  end
+
+  def clear_line(*args)
+    draw_flush
+    @buffer.clear_line(*args)
+    @adapter.clear_line(*args) unless suppressed?
+  end
+
+  def set(x,y,c,fg,bg,mode)
+    # MUST be before the @buffer.set below, as draw_buffered compares
+    # against the buffer's *current* content to avoid redundant redraws.
+    # Skipped while scrolled back so live output does not paint over the
+    # scrolled-back view (the buffer still updates).
+    #
+    # draw_buffered reads the cell's four fields synchronously and never
+    # retains the array, so we reuse a per-instance scratch cell instead of
+    # allocating [c,fg,bg,mode] per character. Safe: a single processing
+    # thread, with no re-entrancy back into #set.
+    unless @defer || @adapter.scrollback_mode
+      s = (@scratch ||= [])
+      s[0], s[1], s[2], s[3] = c, fg, bg, mode
+      draw_buffered(x, y, s)
+    end
+    @buffer.set(x,y,c,fg,bg,mode)
+  end
+
+  def on_resize(w,h)
+    raise if !h
+    @rows = h   # used as the default scroll-region bottom in scroll_up
+    # FIXME: Window is currently resized separately.
+    @buffer.on_resize(w,h)
+  end
+  
+  # Explicit delegations to the underlying buffer, replacing a catch-all
+  # method_missing so the buffer's surface through TrackChanges is
+  # knowable. Each is a model-only mutation whose on-screen redraw the
+  # caller drives separately (Term#redraw_line_from_cursor after
+  # insert/delete_chars; Term#set_line_attrs after set_lineattrs) or a
+  # read-only query - none of them paint, which is why they bypass the
+  # adapter. (The scroll_start/scroll_end getters are defined above; only
+  # the setters delegate.)
+  def insert(*args)        = @buffer.insert(*args)
+  def delete_chars(*args)  = @buffer.delete_chars(*args)
+  def set_lineattrs(*args) = @buffer.set_lineattrs(*args)
+  def scroll_start=(v); @buffer.scroll_start = v; end
+  def scroll_end=(v);   @buffer.scroll_end = v;   end
+  def scrollback_size      = @buffer.scrollback_size
+  def each_character_between(*args, &block) = @buffer.each_character_between(*args, &block)
+
+  def redraw_blink
+    return nil if suppressed?
+    b = @buffer.blinky
+    return nil if b.empty?
+    b.each { |x,y| redraw(x,y) }
+    draw_flush
+  end
+
+  def redraw(x,y) = draw_buffered(x,y, @buffer.get(x,y), true)
+
+  # Render the cursor overlay at (x,y) if +visible+, after restoring the
+  # cell under its previous position. A no-op while scrolled back, so the
+  # live cursor doesn't paint over the frozen history view.
+  def draw_cursor(x, y, visible)
+    return if suppressed?
+    clear_cursor
+    return unless visible
+    redraw_with(x, y, bg: CURSOR)
+    @cursor_pos = [x, y]
+  end
+
+  def clear_cursor
+    return if suppressed?
+    return unless @cursor_pos
+    redraw(*@cursor_pos)
+    @cursor_pos = nil
+  end
+
+  def redraw_all(scrollback_offset = 0)
+    @buffer.each_character(scrollback_offset) { |*args| draw_buffered(*args, true) }
+    # We just force-drew every cell, so nothing is damaged relative to now:
+    # advance the watermark before flushing so the damage walk doesn't redraw
+    # it all again (and so the next incremental flush only sees new changes).
+    @last_flush_gen = @buffer.generation
+    draw_flush
+  end
+
+  def redraw_with(x,y, fg: nil, bg: nil)
+    cell = Array(@buffer.get(x,y)).dup
+    cell[0] ||= " "
+    cell[1] = fg if fg
+    cell[2] = bg if bg
+    draw_buffered(x,y, cell, true)
+  end
+
+  # Draw an already-resolved cell at a *screen* position, optionally
+  # overriding fg/bg. Used when the cell's buffer row and its screen row
+  # differ (selection highlighting while scrolled back into scrollback).
+  def redraw_cell_at(screen_x, screen_y, cell, fg: nil, bg: nil)
+    cell = Array(cell).dup
+    cell[0] ||= " "
+    cell[1] = fg if fg
+    cell[2] = bg if bg
+    draw_buffered(screen_x, screen_y, cell, true)
+  end
+
+  # Repaint whatever is currently displayed at a screen position, given the
+  # active scrollback offset (so scrollback rows repaint their scrolled-off
+  # content rather than the live buffer's).
+  def redraw_display(screen_x, screen_y, scrollback_offset = 0)
+    buffer_y = screen_y - scrollback_offset
+    draw_buffered(screen_x, screen_y, @buffer.get(screen_x, buffer_y), true)
+  end
+
+  # Public flush point. In the default (eager) mode draws already happened
+  # on #set, so this just emits the pending run. In damage-driven (defer)
+  # mode #set only mutates, so a flush first walks the buffer's damage and
+  # draws the changed cells (run-batched) before emitting. Either way it
+  # then emits the run buffer, which also carries force-redraws (cursor,
+  # ICH/DCH, blink, selection).
+  def draw_flush
+    return if @suspend   # jump-scrolling: defer all rendering to the redraw
+    if @defer && !@adapter.scrollback_mode
+      @buffer.each_damaged(@last_flush_gen) do |x, y, ch, fg, bg, flags|
+        s = (@scratch ||= [])
+        s[0], s[1], s[2], s[3] = ch, fg, bg, flags
+        draw_buffered(x, y, s, true)
+      end
+      @last_flush_gen = @buffer.generation
+    end
+    flush_buf
+  end
+
+  # Emit the batched run and reset the batch. Internal: draw_buffered calls
+  # this on a run break, so it must NOT re-enter the damage walk above.
+  def flush_buf
+    if @bufx && @buf && @buf[0] && !@buf[0].empty?
+      c = @buf[0]
+      fg = @buf[1] || PALETTE_BASIC[7]
+      bg = @buf[2] || PALETTE_BASIC[0]
+      if c == " " && fg == 0 && bg == 0 # Why?
+      else
+        lineattrs = @buffer.lineattrs(@bufy)
+        flags = @buf[3].to_i
+        #p [:flush, fg, c]
+        @adapter.draw(@bufx, @bufy, c, fg, bg, flags, lineattrs)
+      end
+    end
+    @buf = []
+    @bufx = nil
+    @bufy = nil
+    @last_x = -2
+    @last_y = -2
+  end
+
+
+  # This is a hack
+  def draw_buffered(x,y,cell, force=false)
+    @last_x ||= -255
+    @last_y ||= -255
+    @buf ||= ["",PALETTE_BASIC[7], PALETTE_BASIC[0],0]
+    cell ||= [" "]
+
+    #p [:buffered, x, y, cell, @bufx, @bufy, @buf, force]
+    if @buf[0] && @buf[0].length > 160
+      flush_buf
+    elsif @last_y != y || @last_x + 1 != x
+      flush_buf
+    elsif (@buf[1] != cell[1]) or (@buf[2] != cell[2]) or (@buf[3] != cell[3])
+      flush_buf
+    else
+    end
+
+    # FIXME: It is possible this is called from multiple threads.
+    # Uh oh. That *will* be trouble. Either changes must be serialized -
+    # they certainly must be for the backend screen buffer - or
+    # this must be made thread local.
+    #
+    @buf[0] ||= ""
+
+    # This is to get better performance out of applications that
+    # carelessly prints far more than they ought to.
+    # *cough* my editor *cough*
+    if force
+      match = false
+    else
+      # Skip the draw if the buffer already holds this exact cell, or if
+      # we're writing a default-background space over an unset cell.
+      # Compared against the buffer's columnar storage directly, so no cell
+      # Array is reconstructed per character.
+      # FIXME: Make this more deliberate about *background* attributes.
+      match = (cell[0] == 32 && cell[2] == BG && @buffer.unset?(x, y)) ||
+              @buffer.cell_eq?(x, y, cell[0], cell[1], cell[2], cell[3])
+    end
+
+    # FIXME: The #to_s here is a workaround for thread sync issues.
+    if @buf[0].to_s.empty?
+      if match
+        return
+      else
+        #p [:diff, x,y, cell, bcell]
+      end
+    elsif match
+      # This heuristic could probably be better:
+      # * Keep a count, and trigger on the *number of matches*
+      #   instead of on the number of characters. This to e.g. prevent a
+      #   single coinciding character from splitting up the rendering into
+      #   8-char chunks
+      #p [:match_non_empty, @buf[0].length]
+      if @buf[0]&.length.to_i > 8
+        # If flushing here, chop the buffer down to the point of the first
+        # match.
+        flush_buf
+        return
+      end
+    end
+
+    c = cell[0]
+
+    @buf[1] ||= cell[1]
+    @buf[2] ||= cell[2]
+    @buf[3] ||= cell[3]
+    @buf[0] ||= ""
+    @buf[0] << (c || "")
+    @bufx ||= x
+    @bufy ||= y
+    @last_x = x
+    @last_y = y
+  end
+
+end