From 97a5069f8c15c283648576791375439486130e2f Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Tue, 31 Mar 2026 11:52:58 -0700 Subject: [PATCH 01/15] Refactor so isWrapped isn't public writeable. Instead to change isWrapped state use a Buffer.setWrapped method. This allows for potential flexibility in how BufferLine and line-wrapping are implemented. --- src/browser/TestUtils.test.ts | 3 ++ src/browser/services/SelectionService.test.ts | 12 +++--- src/common/InputHandler.ts | 42 +++++++++---------- src/common/Types.ts | 2 +- src/common/WindowsMode.ts | 6 +-- src/common/buffer/Buffer.test.ts | 34 +++++++-------- src/common/buffer/Buffer.ts | 7 +++- src/common/buffer/BufferLine.ts | 18 ++++++-- src/common/buffer/Types.ts | 1 + src/common/services/BufferService.ts | 3 +- 10 files changed, 73 insertions(+), 55 deletions(-) diff --git a/src/browser/TestUtils.test.ts b/src/browser/TestUtils.test.ts index 485900e41a..b6bc43cffa 100644 --- a/src/browser/TestUtils.test.ts +++ b/src/browser/TestUtils.test.ts @@ -270,6 +270,9 @@ export class MockBuffer implements IBuffer { public clearAllMarkers(): void { throw new Error('Method not implemented.'); } + public setWrapped(row: number): void { + throw new Error('Method not implemented.'); + } } export class MockRenderer implements IRenderer { diff --git a/src/browser/services/SelectionService.test.ts b/src/browser/services/SelectionService.test.ts index 8deedb751c..8ee04b7e3d 100644 --- a/src/browser/services/SelectionService.test.ts +++ b/src/browser/services/SelectionService.test.ts @@ -193,7 +193,7 @@ describe('SelectionService', () => { it('should expand upwards or downards for wrapped lines', () => { buffer.lines.set(0, stringToRow(' foo')); buffer.lines.set(1, stringToRow('bar ')); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); selectionService.selectWordAt([1, 1]); assert.equal(selectionService.selectionText, 'foobar'); selectionService.model.clearSelection(); @@ -207,10 +207,10 @@ describe('SelectionService', () => { buffer.lines.set(2, stringToRow('bbbbbbbbbbbbbbbbbbbb')); buffer.lines.set(3, stringToRow('cccccccccccccccccccc')); buffer.lines.set(4, stringToRow('bar ')); - buffer.lines.get(1)!.isWrapped = true; - buffer.lines.get(2)!.isWrapped = true; - buffer.lines.get(3)!.isWrapped = true; - buffer.lines.get(4)!.isWrapped = true; + buffer.setWrapped(1, true); + buffer.setWrapped(2, true); + buffer.setWrapped(3, true); + buffer.setWrapped(4, true); selectionService.selectWordAt([18, 0]); assert.equal(selectionService.selectionText, expectedText); selectionService.model.clearSelection(); @@ -349,8 +349,8 @@ describe('SelectionService', () => { it('should select the entire wrapped line', () => { buffer.lines.set(0, stringToRow('foo')); const line2 = stringToRow('bar'); - line2.isWrapped = true; buffer.lines.set(1, line2); + buffer.setWrapped(1, true); selectionService.selectLineAt(0); assert.equal(selectionService.selectionText, 'foobar', 'The selected text is correct'); assert.deepEqual(selectionService.model.selectionStart, [0, 0]); diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index 68265c5df4..361eb8d875 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -609,7 +609,7 @@ export class InputHandler extends Disposable implements IInputHandler { } // The line already exists (eg. the initial viewport), mark it as a // wrapped line - this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!.isWrapped = true; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, true); } // row changed, get it again bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y); @@ -773,7 +773,7 @@ export class InputHandler extends Disposable implements IInputHandler { // reprint is common, especially on resize. Note that the windowsMode wrapped line heuristics // can mess with this so windowsMode should be disabled, which is recommended on Windows build // 21376 and above. - this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!.isWrapped = false; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, false); } // If the end of the line is hit, prevent this action from wrapping around to the next line. if (this._activeBuffer.x >= this._bufferService.cols) { @@ -837,7 +837,7 @@ export class InputHandler extends Disposable implements IInputHandler { && this._activeBuffer.y > this._activeBuffer.scrollTop && this._activeBuffer.y <= this._activeBuffer.scrollBottom && this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)?.isWrapped) { - this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!.isWrapped = false; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, false); this._activeBuffer.y--; this._activeBuffer.x = this._bufferService.cols - 1; // find last taken cell - last cell can have 3 different states: @@ -1201,7 +1201,7 @@ export class InputHandler extends Disposable implements IInputHandler { respectProtect ); if (clearWrap) { - line.isWrapped = false; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + y, false); } } @@ -1215,7 +1215,7 @@ export class InputHandler extends Disposable implements IInputHandler { if (line) { line.fill(this._activeBuffer.getNullCell(this._eraseAttrData()), respectProtect); this._bufferService.buffer.clearMarkers(this._activeBuffer.ybase + y); - line.isWrapped = false; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + y, false); } } @@ -1263,10 +1263,7 @@ export class InputHandler extends Disposable implements IInputHandler { this._eraseInBufferLine(j, 0, this._activeBuffer.x + 1, true, respectProtect); if (this._activeBuffer.x + 1 >= this._bufferService.cols) { // Deleted entire previous line. This next line can no longer be wrapped. - const nextLine = this._activeBuffer.lines.get(j + 1); - if (nextLine) { - nextLine.isWrapped = false; - } + this._activeBuffer.setWrapped(j + 1, false); } while (j--) { this._resetBufferLine(j, respectProtect); @@ -1528,9 +1525,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + const line = this._activeBuffer.lines.get(row)!; line.deleteCells(0, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; + this._activeBuffer.setWrapped(row, false); } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1561,9 +1559,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + const line = this._activeBuffer.lines.get(row)!; + this._activeBuffer.setWrapped(row, false); line.insertCells(0, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1584,9 +1583,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + this._activeBuffer.setWrapped(row, false); + const line = this._activeBuffer.lines.get(row)!; line.insertCells(this._activeBuffer.x, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1607,9 +1607,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + const line = this._activeBuffer.lines.get(row)!; + this._activeBuffer.setWrapped(row, false); line.deleteCells(this._activeBuffer.x, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -3494,11 +3495,8 @@ export class InputHandler extends Disposable implements IInputHandler { this._setCursor(0, 0); for (let yOffset = 0; yOffset < this._bufferService.rows; ++yOffset) { const row = this._activeBuffer.ybase + this._activeBuffer.y + yOffset; - const line = this._activeBuffer.lines.get(row); - if (line) { - line.fill(cell); - line.isWrapped = false; - } + this._activeBuffer.setWrapped(row, false); + this._activeBuffer.lines.get(row)?.fill(cell); } this._dirtyRowTracker.markAllDirty(); this._setCursor(0, 0); diff --git a/src/common/Types.ts b/src/common/Types.ts index 0a9c89a1a0..4e5cbb19a8 100644 --- a/src/common/Types.ts +++ b/src/common/Types.ts @@ -224,7 +224,7 @@ export interface ICellData extends IAttributeData { */ export interface IBufferLine { length: number; - isWrapped: boolean; + get isWrapped(): boolean; get(index: number): CharData; set(index: number, value: CharData): void; loadCell(index: number, cell: ICellData): ICellData; diff --git a/src/common/WindowsMode.ts b/src/common/WindowsMode.ts index 7cff094b2c..22ba1e2a92 100644 --- a/src/common/WindowsMode.ts +++ b/src/common/WindowsMode.ts @@ -19,9 +19,7 @@ export function updateWindowsModeWrappedState(bufferService: IBufferService): vo // wrapped. const line = bufferService.buffer.lines.get(bufferService.buffer.ybase + bufferService.buffer.y - 1); const lastChar = line?.get(bufferService.cols - 1); - - const nextLine = bufferService.buffer.lines.get(bufferService.buffer.ybase + bufferService.buffer.y); - if (nextLine && lastChar) { - nextLine.isWrapped = (lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE && lastChar[CHAR_DATA_CODE_INDEX] !== WHITESPACE_CELL_CODE); + if (lastChar) { + bufferService.buffer.setWrapped(bufferService.buffer.ybase + bufferService.buffer.y, lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE && lastChar[CHAR_DATA_CODE_INDEX] !== WHITESPACE_CELL_CODE); } } diff --git a/src/common/buffer/Buffer.test.ts b/src/common/buffer/Buffer.test.ts index 9c013c5def..dd0d90fb93 100644 --- a/src/common/buffer/Buffer.test.ts +++ b/src/common/buffer/Buffer.test.ts @@ -68,40 +68,40 @@ describe('Buffer', () => { describe('wrapped', () => { it('should return a range for the first row', () => { buffer.fillViewportRows(); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); assert.deepEqual(buffer.getWrappedRangeForLine(0), { first: 0, last: 1 }); }); it('should return a range for a middle row wrapping upwards', () => { buffer.fillViewportRows(); - buffer.lines.get(12)!.isWrapped = true; + buffer.setWrapped(12, true); assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 11, last: 12 }); }); it('should return a range for a middle row wrapping downwards', () => { buffer.fillViewportRows(); - buffer.lines.get(13)!.isWrapped = true; + buffer.setWrapped(13, true); assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 12, last: 13 }); }); it('should return a range for a middle row wrapping both ways', () => { buffer.fillViewportRows(); - buffer.lines.get(11)!.isWrapped = true; - buffer.lines.get(12)!.isWrapped = true; - buffer.lines.get(13)!.isWrapped = true; - buffer.lines.get(14)!.isWrapped = true; + buffer.setWrapped(11, true); + buffer.setWrapped(12, true); + buffer.setWrapped(13, true); + buffer.setWrapped(14, true); assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 10, last: 14 }); }); it('should return a range for the last row', () => { buffer.fillViewportRows(); - buffer.lines.get(23)!.isWrapped = true; + buffer.setWrapped(23, true); assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 1), { first: 22, last: 23 }); }); it('should return a range for a row that wraps upward to first row', () => { buffer.fillViewportRows(); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); assert.deepEqual(buffer.getWrappedRangeForLine(1), { first: 0, last: 1 }); }); it('should return a range for a row that wraps downward to last row', () => { buffer.fillViewportRows(); - buffer.lines.get(buffer.lines.length - 1)!.isWrapped = true; + buffer.setWrapped(buffer.lines.length - 1, true); assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 2), { first: 22, last: 23 }); }); }); @@ -526,7 +526,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(1, [0, 'b', 1, 'b'.charCodeAt(0)]); buffer.lines.get(1)!.set(0, [0, 'c', 1, 'c'.charCodeAt(0)]); buffer.lines.get(1)!.set(1, [0, 'd', 1, 'd'.charCodeAt(0)]); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // "ab " (wrapped) // "cd" @@ -557,7 +557,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(i, [0, '', 0, 0]); buffer.lines.get(1)!.set(i, [0, '', 0, 0]); } - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // 汉语汉语汉语 (wrapped) // 汉语汉语汉语 @@ -584,7 +584,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(1, [0, 'b', 1, 'b'.charCodeAt(0)]); buffer.lines.get(1)!.set(0, [0, 'c', 1, 'c'.charCodeAt(0)]); buffer.lines.get(1)!.set(1, [0, 'd', 1, 'd'.charCodeAt(0)]); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // "ab " (wrapped) // "cd" @@ -618,7 +618,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(i, [0, '', 0, 0]); buffer.lines.get(1)!.set(i, [0, '', 0, 0]); } - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // 汉语汉语汉语 (wrapped) // 汉语汉语汉语 @@ -673,17 +673,17 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(1, [0, 'b', 1, 'b'.charCodeAt(0)]); buffer.lines.get(1)!.set(0, [0, 'c', 1, 'c'.charCodeAt(0)]); buffer.lines.get(1)!.set(1, [0, 'd', 1, 'd'.charCodeAt(0)]); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); buffer.lines.get(2)!.set(0, [0, 'e', 1, 'e'.charCodeAt(0)]); buffer.lines.get(2)!.set(1, [0, 'f', 1, 'f'.charCodeAt(0)]); buffer.lines.get(3)!.set(0, [0, 'g', 1, 'g'.charCodeAt(0)]); buffer.lines.get(3)!.set(1, [0, 'h', 1, 'h'.charCodeAt(0)]); - buffer.lines.get(3)!.isWrapped = true; + buffer.setWrapped(3, true); buffer.lines.get(4)!.set(0, [0, 'i', 1, 'i'.charCodeAt(0)]); buffer.lines.get(4)!.set(1, [0, 'j', 1, 'j'.charCodeAt(0)]); buffer.lines.get(5)!.set(0, [0, 'k', 1, 'k'.charCodeAt(0)]); buffer.lines.get(5)!.set(1, [0, 'l', 1, 'l'.charCodeAt(0)]); - buffer.lines.get(5)!.isWrapped = true; + buffer.setWrapped(5, true); }); describe('viewport not yet filled', () => { it('should move the cursor up and add empty lines', () => { diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index 8efefd60a4..b7de7e7416 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -121,6 +121,11 @@ export class Buffer implements IBuffer { return correctBufferLength > MAX_BUFFER_SIZE ? MAX_BUFFER_SIZE : correctBufferLength; } + public setWrapped(absrow: number, value: boolean): void { + const line = this.lines.get(absrow); + line instanceof BufferLine && line.setWrapped(value); + } + /** * Fills the buffer's viewport with blank lines. */ @@ -135,7 +140,7 @@ export class Buffer implements IBuffer { } /** - * Clears the buffer to it's initial state, discarding all previous data. + * Clears the buffer to its initial state, discarding all previous data. */ public clear(): void { this.ydisp = 0; diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index e415851a0a..b7921942c8 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -64,14 +64,26 @@ export class BufferLine implements IBufferLine { protected _combined: {[index: number]: string} = {}; protected _extendedAttrs: {[index: number]: IExtendedAttrs | undefined} = {}; public length: number; + private _isWrapped: boolean; - constructor(cols: number, fillCellData?: ICellData, public isWrapped: boolean = false) { + public get isWrapped(): boolean { + return this._isWrapped; + } + /** + * @internal + */ + public setWrapped(isWrapped: boolean): void { + this._isWrapped = isWrapped; + } + + constructor(cols: number, fillCellData?: ICellData, isWrapped: boolean = false) { this._data = new Uint32Array(cols * CELL_SIZE); const cell = fillCellData ?? CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]); for (let i = 0; i < cols; ++i) { this.setCell(i, cell); } this.length = cols; + this._isWrapped = isWrapped; } /** @@ -439,7 +451,7 @@ export class BufferLine implements IBufferLine { for (const el in line._extendedAttrs) { this._extendedAttrs[el] = line._extendedAttrs[el]; } - this.isWrapped = line.isWrapped; + this._isWrapped = line._isWrapped; } /** create a new clone */ @@ -453,7 +465,7 @@ export class BufferLine implements IBufferLine { for (const el in this._extendedAttrs) { newLine._extendedAttrs[el] = this._extendedAttrs[el]; } - newLine.isWrapped = this.isWrapped; + newLine._isWrapped = this._isWrapped; return newLine; } diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts index 85dd68eec2..a7e7321f2f 100644 --- a/src/common/buffer/Types.ts +++ b/src/common/buffer/Types.ts @@ -39,6 +39,7 @@ export interface IBuffer { addMarker(y: number): IMarker; clearMarkers(y: number): void; clearAllMarkers(): void; + setWrapped(row: number, value: boolean): void; } export interface IBufferSet extends IDisposable { diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index 6a7ce2b343..e71bc04ab1 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -6,6 +6,7 @@ import { Disposable } from 'common/Lifecycle'; import { IAttributeData, IBufferLine } from 'common/Types'; import { BufferSet } from 'common/buffer/BufferSet'; +import { BufferLine } from 'common/buffer/BufferLine'; import { IBuffer, IBufferSet } from 'common/buffer/Types'; import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services'; import { Emitter } from 'common/Event'; @@ -73,7 +74,7 @@ export class BufferService extends Disposable implements IBufferService { newLine = buffer.getBlankLine(eraseAttr, isWrapped); this._cachedBlankLine = newLine; } - newLine.isWrapped = isWrapped; + (newLine as BufferLine).setWrapped(isWrapped); const topRow = buffer.ybase + buffer.scrollTop; const bottomRow = buffer.ybase + buffer.scrollBottom; From e9ea22f00556021ac821b210efad0762e5bc79bf Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Sun, 5 Apr 2026 21:27:51 -0700 Subject: [PATCH 02/15] Fix MockBuffer.setWrapped. --- src/browser/TestUtils.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/browser/TestUtils.test.ts b/src/browser/TestUtils.test.ts index b6bc43cffa..8fd6cb2cf5 100644 --- a/src/browser/TestUtils.test.ts +++ b/src/browser/TestUtils.test.ts @@ -270,7 +270,7 @@ export class MockBuffer implements IBuffer { public clearAllMarkers(): void { throw new Error('Method not implemented.'); } - public setWrapped(row: number): void { + public setWrapped(row: number, value: boolean): void { throw new Error('Method not implemented.'); } } From bd79ccc82acb8cd87756378bd6b30007c9fca310 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Mon, 6 Apr 2026 18:42:22 -0700 Subject: [PATCH 03/15] Move "data" from BufferLine to new LogicalLine class. A BufferLine is now the sub-range of a LogicalLine for a specific visible line, while LogicalLine is independent of window width. --- src/common/CircularList.ts | 14 - src/common/InputHandler.test.ts | 9 +- src/common/InputHandler.ts | 61 ++- src/common/Types.ts | 2 - src/common/buffer/Buffer.test.ts | 29 -- src/common/buffer/Buffer.ts | 225 ++++---- src/common/buffer/BufferLine.test.ts | 49 +- src/common/buffer/BufferLine.ts | 694 ++++++++++++++++++------- src/common/buffer/BufferReflow.test.ts | 68 ++- src/common/buffer/BufferReflow.ts | 145 +----- src/common/buffer/CellData.ts | 4 +- src/common/buffer/Constants.ts | 1 + src/common/buffer/Types.ts | 20 + src/common/services/BufferService.ts | 34 +- 14 files changed, 797 insertions(+), 558 deletions(-) diff --git a/src/common/CircularList.ts b/src/common/CircularList.ts index 3663bfc178..ffa3719f7c 100644 --- a/src/common/CircularList.ts +++ b/src/common/CircularList.ts @@ -115,20 +115,6 @@ export class CircularList extends Disposable implements ICircularList { } } - /** - * Advance ringbuffer index and return current element for recycling. - * Note: The buffer must be full for this method to work. - * @throws When the buffer is not full. - */ - public recycle(): T { - if (this._length !== this._maxLength) { - throw new Error('Can only recycle when the buffer is full'); - } - this._startIndex = ++this._startIndex % this._maxLength; - this.onTrimEmitter.fire(1); - return this._array[this._getCyclicIndex(this._length - 1)]!; - } - /** * Ringbuffer is at max length. */ diff --git a/src/common/InputHandler.test.ts b/src/common/InputHandler.test.ts index f9da81a25e..12ca3fa472 100644 --- a/src/common/InputHandler.test.ts +++ b/src/common/InputHandler.test.ts @@ -459,8 +459,10 @@ describe('InputHandler', () => { await resetToBaseState(); bufferService.buffer.y = 2; bufferService.buffer.x = 40; - inputHandler.eraseInLine(Params.fromArray([0])); assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true); + assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, true); + inputHandler.eraseInLine(Params.fromArray([0])); + assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true);assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false); bufferService.buffer.y = 2; bufferService.buffer.x = 0; inputHandler.eraseInLine(Params.fromArray([0])); @@ -471,14 +473,15 @@ describe('InputHandler', () => { bufferService.buffer.y = 2; bufferService.buffer.x = 40; inputHandler.eraseInLine(Params.fromArray([1])); - assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, true); + assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false); + assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, true); // params[2] - erase complete line await resetToBaseState(); bufferService.buffer.y = 2; bufferService.buffer.x = 40; inputHandler.eraseInLine(Params.fromArray([2])); - assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false); + assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false); }); it('ED2 with scrollOnEraseInDisplay turned on', async () => { const inputHandler = new TestInputHandler( diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index 361eb8d875..e7482902d0 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -596,8 +596,8 @@ export class InputHandler extends Disposable implements IInputHandler { // autowrap - DECAWM // automatically wraps to the beginning of the next line if (wraparoundMode) { - const oldRow = bufferRow; - let oldCol = this._activeBuffer.x - oldWidth; + const oldRow = bufferRow as BufferLine; + const oldCol = this._activeBuffer.x - oldWidth; this._activeBuffer.x = oldWidth; this._activeBuffer.y++; if (this._activeBuffer.y === this._activeBuffer.scrollBottom + 1) { @@ -623,9 +623,7 @@ export class InputHandler extends Disposable implements IInputHandler { oldCol, 0, oldWidth, false); } // clear left over cells to the right - while (oldCol < cols) { - oldRow.setCellFromCodepoint(oldCol++, 0, 1, curAttr); - } + oldRow.eraseRight(oldCol); } else { this._activeBuffer.x = cols - 1; if (chWidth === 2) { @@ -1183,24 +1181,33 @@ export class InputHandler extends Disposable implements IInputHandler { /** * Helper method to erase cells in a terminal row. * The cell gets replaced with the eraseChar of the terminal. + * Clear isWrapped if start===0; + * clear isWrapped of next line if end >= cols. * @param y The row index relative to the viewport. * @param start The start x index of the range to be erased. * @param end The end x index of the range to be erased (exclusive). - * @param clearWrap clear the isWrapped flag * @param respectProtect Whether to respect the protection attribute (DECSCA). */ - private _eraseInBufferLine(y: number, start: number, end: number, clearWrap: boolean = false, respectProtect: boolean = false): void { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y); - if (!line) { + private _eraseInBufferLine(y: number, start: number, end: number, respectProtect: boolean = false): void { + const yAbs = y + this._activeBuffer.ybase; + const line = this._activeBuffer.lines.get(yAbs); + if (! (line instanceof BufferLine)) { return; } - line.replaceCells( - start, - end, - this._activeBuffer.getNullCell(this._eraseAttrData()), - respectProtect - ); - if (clearWrap) { + if (! respectProtect && end >= this._bufferService.cols) { + const next = line.nextBufferLine; + if (next) next.asUnwrapped(line); + line.eraseRight(start); + line.logicalLine.backgroundColor = this._curAttrData.bg & ~0xFC000000; + } else { + line.replaceCells( + start, + end, + this._activeBuffer.getNullCell(this._eraseAttrData()), + respectProtect + ); + } + if (start === 0) { this._activeBuffer.setWrapped(this._activeBuffer.ybase + y, false); } } @@ -1211,12 +1218,8 @@ export class InputHandler extends Disposable implements IInputHandler { * @param y row index */ private _resetBufferLine(y: number, respectProtect: boolean = false): void { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y); - if (line) { - line.fill(this._activeBuffer.getNullCell(this._eraseAttrData()), respectProtect); - this._bufferService.buffer.clearMarkers(this._activeBuffer.ybase + y); - this._activeBuffer.setWrapped(this._activeBuffer.ybase + y, false); - } + this._eraseInBufferLine(y, 0, this._bufferService.cols, respectProtect); + this._bufferService.buffer.clearMarkers(this._activeBuffer.ybase + y); } /** @@ -1250,7 +1253,7 @@ export class InputHandler extends Disposable implements IInputHandler { case 0: j = this._activeBuffer.y; this._dirtyRowTracker.markDirty(j); - this._eraseInBufferLine(j++, this._activeBuffer.x, this._bufferService.cols, this._activeBuffer.x === 0, respectProtect); + this._eraseInBufferLine(j++, this._activeBuffer.x, this._bufferService.cols, respectProtect); for (; j < this._bufferService.rows; j++) { this._resetBufferLine(j, respectProtect); } @@ -1260,11 +1263,7 @@ export class InputHandler extends Disposable implements IInputHandler { j = this._activeBuffer.y; this._dirtyRowTracker.markDirty(j); // Deleted front part of line and everything before. This line will no longer be wrapped. - this._eraseInBufferLine(j, 0, this._activeBuffer.x + 1, true, respectProtect); - if (this._activeBuffer.x + 1 >= this._bufferService.cols) { - // Deleted entire previous line. This next line can no longer be wrapped. - this._activeBuffer.setWrapped(j + 1, false); - } + this._eraseInBufferLine(j, 0, this._activeBuffer.x + 1, respectProtect); while (j--) { this._resetBufferLine(j, respectProtect); } @@ -1334,13 +1333,13 @@ export class InputHandler extends Disposable implements IInputHandler { this._restrictCursor(this._bufferService.cols); switch (params.params[0]) { case 0: - this._eraseInBufferLine(this._activeBuffer.y, this._activeBuffer.x, this._bufferService.cols, this._activeBuffer.x === 0, respectProtect); + this._eraseInBufferLine(this._activeBuffer.y, this._activeBuffer.x, this._bufferService.cols, respectProtect); break; case 1: - this._eraseInBufferLine(this._activeBuffer.y, 0, this._activeBuffer.x + 1, false, respectProtect); + this._eraseInBufferLine(this._activeBuffer.y, 0, this._activeBuffer.x + 1, respectProtect); break; case 2: - this._eraseInBufferLine(this._activeBuffer.y, 0, this._bufferService.cols, true, respectProtect); + this._eraseInBufferLine(this._activeBuffer.y, 0, this._bufferService.cols, respectProtect); break; } this._dirtyRowTracker.markDirty(this._activeBuffer.y); diff --git a/src/common/Types.ts b/src/common/Types.ts index 4e5cbb19a8..073f964913 100644 --- a/src/common/Types.ts +++ b/src/common/Types.ts @@ -77,7 +77,6 @@ export interface ICircularList { get(index: number): T | undefined; set(index: number, value: T): void; push(value: T): void; - recycle(): T; pop(): T | undefined; splice(start: number, deleteCount: number, ...items: T[]): void; trimStart(count: number): void; @@ -238,7 +237,6 @@ export interface IBufferLine { cleanupMemory(): number; fill(fillCellData: ICellData, respectProtect?: boolean): void; copyFrom(line: IBufferLine): void; - clone(): IBufferLine; getTrimmedLength(): number; getNoBgTrimmedLength(): number; translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string; diff --git a/src/common/buffer/Buffer.test.ts b/src/common/buffer/Buffer.test.ts index dd0d90fb93..fb6eadd83d 100644 --- a/src/common/buffer/Buffer.test.ts +++ b/src/common/buffer/Buffer.test.ts @@ -1178,33 +1178,4 @@ describe('Buffer', () => { assert.equal(str3, '😁a'); }); }); - - describe('memory cleanup after shrinking', () => { - it('should realign memory from idle task execution', async () => { - buffer.fillViewportRows(); - - // shrink more than 2 times to trigger lazy memory cleanup - buffer.resize(INIT_COLS / 2 - 1, INIT_ROWS); - - // sync - for (let i = 0; i < INIT_ROWS; i++) { - const line = buffer.lines.get(i)!; - // line memory is still at old size from initialization - assert.equal((line as any)._data.buffer.byteLength, INIT_COLS * 3 * 4); - // array.length and .length get immediately adjusted - assert.equal((line as any)._data.length, (INIT_COLS / 2 - 1) * 3); - assert.equal(line.length, INIT_COLS / 2 - 1); - } - - // wait for a bit to give IdleTaskQueue a chance to kick in - // and finish memory cleaning - await new Promise(r => setTimeout(r, 30)); - - // cleanup should have realigned memory with exact bytelength - for (let i = 0; i < INIT_ROWS; i++) { - const line = buffer.lines.get(i)!; - assert.equal((line as any)._data.buffer.byteLength, (INIT_COLS / 2 - 1) * 3 * 4); - } - }); - }); }); diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index b7de7e7416..cc322c641c 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -4,11 +4,10 @@ */ import { CircularList, IInsertEvent } from 'common/CircularList'; -import { IdleTaskQueue } from 'common/TaskQueue'; import { IAttributeData, IBufferLine, ICellData, ICharset } from 'common/Types'; import { ExtendedAttrs } from 'common/buffer/AttributeData'; -import { BufferLine, DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine'; -import { getWrappedLineTrimmedLength, reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from 'common/buffer/BufferReflow'; +import { BufferLine, LogicalLine, DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine'; +import { reflowLargerApplyNewLayout, reflowLargerCreateNewLayout } from 'common/buffer/BufferReflow'; import { CellData } from 'common/buffer/CellData'; import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH } from 'common/buffer/Constants'; import { Marker } from 'common/buffer/Marker'; @@ -29,6 +28,7 @@ export class Buffer implements IBuffer { public lines: CircularList; public ydisp: number = 0; public ybase: number = 0; + /** Row number, relative to ybase. */ public y: number = 0; public x: number = 0; public scrollBottom: number; @@ -48,8 +48,6 @@ export class Buffer implements IBuffer { private _cols: number; private _rows: number; private _isClearing: boolean = false; - private _memoryCleanupQueue: InstanceType; - private _memoryCleanupPosition = 0; constructor( private _hasScrollback: boolean, @@ -63,7 +61,13 @@ export class Buffer implements IBuffer { this.scrollTop = 0; this.scrollBottom = this._rows - 1; this.setupTabStops(); - this._memoryCleanupQueue = new IdleTaskQueue(this._logService); + + this.lines.onTrim(amount => { + const first = this.lines.length && this.lines.get(0); + if (first instanceof BufferLine && first.isWrapped) { + const prev = first.getPreviousLine(); + prev && first.asUnwrapped(prev); + }}); } public getNullCell(attr?: IAttributeData): ICellData { @@ -92,8 +96,14 @@ export class Buffer implements IBuffer { return this._whitespaceCell; } - public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine { - return new BufferLine(this._bufferService.cols, this.getNullCell(attr), isWrapped); + /** + * Get an empty unwrapped line. + * @param attr Only used for the background color. + */ + public getBlankLine(attr: IAttributeData): IBufferLine { + const lline = new LogicalLine(this._cols); + lline.backgroundColor = attr.bg & ~0xFC000000; + return new BufferLine(this._cols, lline); } public get hasScrollback(): boolean { @@ -123,7 +133,14 @@ export class Buffer implements IBuffer { public setWrapped(absrow: number, value: boolean): void { const line = this.lines.get(absrow); - line instanceof BufferLine && line.setWrapped(value); + if (! line || line.isWrapped === value) + {return;} + const prevRow = this.lines.get(absrow - 1) as BufferLine; + if (value) { + (line as BufferLine).setWrapped(prevRow); + } else { + (line as BufferLine).asUnwrapped(prevRow); + } } /** @@ -160,10 +177,6 @@ export class Buffer implements IBuffer { */ public resize(newCols: number, newRows: number): void { // store reference to null cell with default attrs - const nullCell = this.getNullCell(DEFAULT_ATTR_DATA); - - // count bufferlines with overly big memory to be cleaned afterwards - let dirtyMemoryLines = 0; // Increase max length if needed before adjustments to allow space to fill // as required. @@ -182,8 +195,7 @@ export class Buffer implements IBuffer { // Deal with columns increasing (reducing needs to happen after reflow) if (this._cols < newCols) { for (let i = 0; i < this.lines.length; i++) { - // +boolean for fast 0 or 1 conversion - dirtyMemoryLines += +this.lines.get(i)!.resize(newCols, nullCell); + this.lines.get(i)!.length = newCols; } } @@ -193,9 +205,9 @@ export class Buffer implements IBuffer { for (let y = this._rows; y < newRows; y++) { if (this.lines.length < newRows + this.ybase) { if (this._optionsService.rawOptions.windowsPty.backend !== undefined || this._optionsService.rawOptions.windowsPty.buildNumber !== undefined) { - // Just add the new missing rows on Windows as conpty reprints the screen with it's + // Just add the new missing rows on Windows as conpty reprints the screen with its // view of the world. Once a line enters scrollback for conpty it remains there - this.lines.push(new BufferLine(newCols, nullCell)); + this.lines.push(new BufferLine(newCols)); } else { if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) { // There is room above the buffer and there are no empty elements below the line, @@ -209,7 +221,7 @@ export class Buffer implements IBuffer { } else { // Add a blank line if there is no buffer left at the top to scroll to, or if there // are blank lines after the cursor - this.lines.push(new BufferLine(newCols, nullCell)); + this.lines.push(new BufferLine(newCols)); } } } @@ -262,8 +274,7 @@ export class Buffer implements IBuffer { // Trim the end of the line off if cols shrunk if (this._cols > newCols) { for (let i = 0; i < this.lines.length; i++) { - // +boolean for fast 0 or 1 conversion - dirtyMemoryLines += +this.lines.get(i)!.resize(newCols, nullCell); + this.lines.get(i)!.length = newCols; } } } @@ -277,35 +288,6 @@ export class Buffer implements IBuffer { const maxY = Math.max(0, this.lines.length - this.ybase - 1); this.y = Math.min(this.y, maxY); } - - this._memoryCleanupQueue.clear(); - // schedule memory cleanup only, if more than 10% of the lines are affected - if (dirtyMemoryLines > 0.1 * this.lines.length) { - this._memoryCleanupPosition = 0; - this._memoryCleanupQueue.enqueue(() => this._batchedMemoryCleanup()); - } - } - - private _batchedMemoryCleanup(): boolean { - let normalRun = true; - if (this._memoryCleanupPosition >= this.lines.length) { - // cleanup made it once through all lines, thus rescan in loop below to also catch shifted - // lines, which should finish rather quick if there are no more cleanups pending - this._memoryCleanupPosition = 0; - normalRun = false; - } - let counted = 0; - while (this._memoryCleanupPosition < this.lines.length) { - counted += this.lines.get(this._memoryCleanupPosition++)!.cleanupMemory(); - // cleanup max 100 lines per batch - if (counted > 100) { - return true; - } - } - // normal runs always need another rescan afterwards - // if we made it here with normalRun=false, we are in a final run - // and can end the cleanup task for sure - return normalRun; } private get _isReflowEnabled(): boolean { @@ -329,9 +311,62 @@ export class Buffer implements IBuffer { } } + /** + * Evaluates and returns indexes to be removed after a reflow larger occurs. Lines will be removed + * when a wrapped line unwraps. + * @param lines The buffer lines. + * @param oldCols The columns before resize + * @param newCols The columns after resize. + * @param bufferAbsoluteY The absolute y position of the cursor (baseY + cursorY). + * @param nullCell The cell data to use when filling in empty cells. + * @param reflowCursorLine Whether to reflow the line containing the cursor. + */ + private _reflowLargerGetLinesToRemove(lines: CircularList, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData, reflowCursorLine: boolean): number[] { + // Gather all BufferLines that need to be removed from the Buffer here so that they can be + // batched up and only committed once + const toRemove: number[] = []; + + for (let y = 0; y < lines.length - 1; y++) { + // Check if this row is wrapped + let i = y; + let nextLine = lines.get(++i) as BufferLine; + if (!nextLine.isWrapped) { + continue; + } + + // Check how many lines it's wrapped for + const wrappedLines: BufferLine[] = [lines.get(y) as BufferLine]; + while (i < lines.length && nextLine.isWrapped) { + wrappedLines.push(nextLine); + nextLine = lines.get(++i) as BufferLine; + } + + if (!reflowCursorLine) { + // If these lines contain the cursor don't touch them, the program will handle fixing up + // wrapped lines with the cursor + if (bufferAbsoluteY >= y && bufferAbsoluteY < i) { + y += wrappedLines.length - 1; + continue; + } + } + const oldWrapped = wrappedLines.length; + this._reflowLine(wrappedLines, newCols); + + // Work backwards and remove any rows at the end that only contain null cells + const countToRemove = oldWrapped - wrappedLines.length; + if (countToRemove > 0) { + toRemove.push(y + oldWrapped - countToRemove); // index + toRemove.push(countToRemove); + } + + y += oldWrapped - 1; + } + return toRemove; + } + private _reflowLarger(newCols: number, newRows: number): void { const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine; - const toRemove: number[] = reflowLargerGetLinesToRemove(this.lines, this._cols, newCols, this.ybase + this.y, this.getNullCell(DEFAULT_ATTR_DATA), reflowCursorLine); + const toRemove: number[] = this._reflowLargerGetLinesToRemove(this.lines, this._cols, newCols, this.ybase + this.y, this.getNullCell(DEFAULT_ATTR_DATA), reflowCursorLine); if (toRemove.length > 0) { const newLayoutResult = reflowLargerCreateNewLayout(this.lines, toRemove); reflowLargerApplyNewLayout(this.lines, newLayoutResult.layout); @@ -340,7 +375,6 @@ export class Buffer implements IBuffer { } private _reflowLargerAdjustViewport(newCols: number, newRows: number, countRemoved: number): void { - const nullCell = this.getNullCell(DEFAULT_ATTR_DATA); // Adjust viewport based on number of items removed let viewportAdjustments = countRemoved; while (viewportAdjustments-- > 0) { @@ -350,7 +384,7 @@ export class Buffer implements IBuffer { } if (this.lines.length < newRows) { // Add an extra row at the bottom of the viewport - this.lines.push(new BufferLine(newCols, nullCell)); + this.lines.push(new BufferLine(newCols)); } } else { if (this.ydisp === this.ybase) { @@ -361,10 +395,42 @@ export class Buffer implements IBuffer { } this.savedY = Math.max(this.savedY - countRemoved, 0); } + private _reflowLine(wrappedLines: BufferLine[], newCols: number): BufferLine[] { + const newLines: BufferLine[] = []; + let startCol = 0; + let curRow = 1; + let curLine = wrappedLines[0]; + const logical = curLine.logicalLine; + for (;;) { + const endCol = logical.charStart(startCol + newCols); + if ((this as any).xyz) console.log('-curR:'+curRow+' endCol:'+endCol); + if (endCol >= logical.length) { + curLine.nextBufferLine = undefined; + curLine.startColumn = startCol; + break; + } + let newLine; + if (curRow < wrappedLines.length) { + newLine = wrappedLines[curRow]; + newLine.length = newCols; + } else { + newLine = new BufferLine(newCols, logical); + newLines.push(newLine); + } + curRow++; + newLine.startColumn = endCol; + startCol = endCol; + curLine.nextBufferLine = newLine; + curLine = newLine; + } + if (curRow < wrappedLines.length) { + wrappedLines.length = curRow; + } + return newLines; + } private _reflowSmaller(newCols: number, newRows: number): void { const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine; - const nullCell = this.getNullCell(DEFAULT_ATTR_DATA); // Gather all BufferLines that need to be inserted into the Buffer here so that they can be // batched up and only committed once const toInsert = []; @@ -376,7 +442,6 @@ export class Buffer implements IBuffer { if (!nextLine || !nextLine.isWrapped && nextLine.getTrimmedLength() <= newCols) { continue; } - // Gather wrapped lines and adjust y to be the starting line const wrappedLines: BufferLine[] = [nextLine]; while (nextLine.isWrapped && y > 0) { @@ -392,10 +457,8 @@ export class Buffer implements IBuffer { continue; } } - - const lastLineLength = wrappedLines[wrappedLines.length - 1].getTrimmedLength(); - const destLineLengths = reflowSmallerGetNewLineLengths(wrappedLines, this._cols, newCols); - const linesToAdd = destLineLengths.length - wrappedLines.length; + const newLines = this._reflowLine(wrappedLines, newCols); + const linesToAdd = newLines.length; let trimmedLines: number; if (this.ybase === 0 && this.y !== this.lines.length - 1) { // If the top section of the buffer is not yet filled @@ -404,12 +467,6 @@ export class Buffer implements IBuffer { trimmedLines = Math.max(0, this.lines.length - this.lines.maxLength + linesToAdd); } - // Add the new lines - const newLines: BufferLine[] = []; - for (let i = 0; i < linesToAdd; i++) { - const newLine = this.getBlankLine(DEFAULT_ATTR_DATA, true) as BufferLine; - newLines.push(newLine); - } if (newLines.length > 0) { toInsert.push({ // countToInsert here gets the actual index, taking into account other inserted items. @@ -418,46 +475,8 @@ export class Buffer implements IBuffer { newLines }); countToInsert += newLines.length; + wrappedLines.push(...newLines); } - wrappedLines.push(...newLines); - - // Copy buffer data to new locations, this needs to happen backwards to do in-place - let destLineIndex = destLineLengths.length - 1; // Math.floor(cellsNeeded / newCols); - let destCol = destLineLengths[destLineIndex]; // cellsNeeded % newCols; - if (destCol === 0) { - destLineIndex--; - destCol = destLineLengths[destLineIndex]; - } - let srcLineIndex = wrappedLines.length - linesToAdd - 1; - let srcCol = lastLineLength; - while (srcLineIndex >= 0) { - const cellsToCopy = Math.min(srcCol, destCol); - if (wrappedLines[destLineIndex] === undefined) { - // Sanity check that the line exists, this has been known to fail for an unknown reason - // which would stop the reflow from happening if an exception would throw. - break; - } - wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol - cellsToCopy, destCol - cellsToCopy, cellsToCopy, true); - destCol -= cellsToCopy; - if (destCol === 0) { - destLineIndex--; - destCol = destLineLengths[destLineIndex]; - } - srcCol -= cellsToCopy; - if (srcCol === 0) { - srcLineIndex--; - const wrappedLinesIndex = Math.max(srcLineIndex, 0); - srcCol = getWrappedLineTrimmedLength(wrappedLines, wrappedLinesIndex, this._cols); - } - } - - // Null out the end of the line ends if a wide character wrapped to the following line - for (let i = 0; i < wrappedLines.length; i++) { - if (destLineLengths[i] < newCols) { - wrappedLines[i].setCell(destLineLengths[i], nullCell); - } - } - // Adjust viewport as needed let viewportAdjustments = linesToAdd - trimmedLines; while (viewportAdjustments-- > 0) { diff --git a/src/common/buffer/BufferLine.test.ts b/src/common/buffer/BufferLine.test.ts index dce68ebbfe..8e78b248d6 100644 --- a/src/common/buffer/BufferLine.test.ts +++ b/src/common/buffer/BufferLine.test.ts @@ -3,7 +3,7 @@ * @license MIT */ import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, DEFAULT_ATTR, Content, UnderlineStyle, BgFlags, Attributes, FgFlags } from 'common/buffer/Constants'; -import { BufferLine } from 'common/buffer//BufferLine'; +import { BufferLine, LogicalLine } from 'common/buffer//BufferLine'; import { CellData } from 'common/buffer/CellData'; import { CharData, IBufferLine } from '../Types'; import { assert } from 'chai'; @@ -12,8 +12,21 @@ import { createCellData, NULL_CELL_DATA, extendedAttributes } from 'common/TestU class TestBufferLine extends BufferLine { - public get combined(): {[index: number]: string} { - return this._combined; + constructor(cols: number, fillCellData?: CellData, isWrapped: boolean = false) { + const lline = new LogicalLine(isWrapped ? 2 * cols : cols); + super(cols, lline); + if (isWrapped) { + const prevLine = new BufferLine(cols, lline); + lline.firstBufferLine = prevLine; + prevLine.nextBufferLine = this; + this.startColumn = cols; + fillCellData && prevLine.fill(fillCellData); + } else { + lline.firstBufferLine = this; + } + if (fillCellData) { + this.fill(fillCellData); + } } public toArray(): CharData[] { @@ -239,18 +252,6 @@ describe('BufferLine', function(): void { [123, 'z', 1, 'z'.charCodeAt(0)] ]); }); - it('clone', function(): void { - const line = new TestBufferLine(5, undefined, true); - line.setCell(0, createCellData(1, 'a', 1)); - line.setCell(1, createCellData(2, 'b', 1)); - line.setCell(2, createCellData(3, 'c', 1)); - line.setCell(3, createCellData(4, 'd', 1)); - line.setCell(4, createCellData(5, 'e', 1)); - const line2 = line.clone(); - assert.deepEqual(TestBufferLine.prototype.toArray.apply(line2), line.toArray()); - assert.equal(line2.length, line.length); - assert.equal(line2.isWrapped, line.isWrapped); - }); it('copyFrom', function(): void { const line = new TestBufferLine(5); line.setCell(0, createCellData(1, 'a', 1)); @@ -258,11 +259,10 @@ describe('BufferLine', function(): void { line.setCell(2, createCellData(3, 'c', 1)); line.setCell(3, createCellData(4, 'd', 1)); line.setCell(4, createCellData(5, 'e', 1)); - const line2 = new TestBufferLine(5, createCellData(1, 'a', 1), true); + const line2 = new TestBufferLine(5, createCellData(1, 'a', 1)); line2.copyFrom(line); assert.deepEqual(line2.toArray(), line.toArray()); assert.equal(line2.length, line.length); - assert.equal(line2.isWrapped, line.isWrapped); }); it('should support combining chars', function(): void { // CHAR_DATA_CODE_INDEX resembles current behavior in InputHandler.print @@ -273,8 +273,6 @@ describe('BufferLine', function(): void { const line2 = new TestBufferLine(5, createCellData(1, 'a', 1), true); line2.copyFrom(line); assert.deepEqual(line2.toArray(), line.toArray()); - const line3 = line.clone(); - assert.deepEqual(TestBufferLine.prototype.toArray.apply(line3), line.toArray()); }); describe('resize', function(): void { it('enlarge(false)', function(): void { @@ -299,15 +297,13 @@ describe('BufferLine', function(): void { }); it('should remove combining data on replaced cells after shrinking then enlarging', () => { const line = new TestBufferLine(10, createCellData(1, 'a', 1), false); - line.set(2, [ 0, '😁', 1, '😁'.charCodeAt(0) ]); - line.set(9, [ 0, '😁', 1, '😁'.charCodeAt(0) ]); + line.setCell(2, createCellData(0, '😁', 1)); + line.setCell(9, createCellData(0, '😁', 1)); assert.equal(line.translateToString(), 'aa😁aaaaaa😁'); - assert.equal(Object.keys(line.combined).length, 2); line.resize(5, createCellData(1, 'a', 1)); assert.equal(line.translateToString(), 'aa😁aa'); line.resize(10, createCellData(1, 'a', 1)); assert.equal(line.translateToString(), 'aa😁aaaaaaa'); - assert.equal(Object.keys(line.combined).length, 1); }); }); describe('getTrimLength', function(): void { @@ -766,13 +762,6 @@ describe('BufferLine', function(): void { // no eAttrs again cell.bg &= ~BgFlags.HAS_EXTENDED; line.setCell(4, cell); - - const nLine = line.clone(); - assert.equal(extendedAttributes(nLine, 0), extendedAttributes(line, 0)); - assert.equal(extendedAttributes(nLine, 1), extendedAttributes(line, 1)); - assert.equal(extendedAttributes(nLine, 2), extendedAttributes(line, 2)); - assert.equal(extendedAttributes(nLine, 3), extendedAttributes(line, 3)); - assert.equal(extendedAttributes(nLine, 4), extendedAttributes(line, 4)); }); it('copyFrom', () => { const initial = new TestBufferLine(5); diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index b7921942c8..ab928eb378 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -6,7 +6,7 @@ import { CharData, IAttributeData, IBufferLine, ICellData, IExtendedAttrs } from 'common/Types'; import { AttributeData } from 'common/buffer/AttributeData'; import { CellData } from 'common/buffer/CellData'; -import { Attributes, BgFlags, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from 'common/buffer/Constants'; +import { Attributes, BgFlags, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from 'common/buffer/Constants'; import { stringFromCodePoint } from 'common/input/TextDecoder'; /** @@ -21,6 +21,18 @@ import { stringFromCodePoint } from 'common/input/TextDecoder'; /** typed array slots taken by one cell */ const CELL_SIZE = 3; +/** Column count within current visible BufferLine(row). + * The left-most column is column 0. + */ +type BufferColumn = number; + +/** Column count within current LogicalLine. + * If the display is 80 columns wide, then LineColumn of the left-most + * character of the first wrapped line would normally be 80. + * (It might be 79 if the character at column 79 is double-width.) + */ +type LogicalColumn = number; + /** * Cell member indices. * @@ -37,13 +49,249 @@ const enum Cell { export const DEFAULT_ATTR_DATA = Object.freeze(new AttributeData()); -// Work variables to avoid garbage collection -let $startIndex = 0; +// Work variable to avoid garbage collection const $workCell = new CellData(); /** Factor when to cleanup underlying array buffer after shrinking. */ const CLEANUP_THRESHOLD = 2; +/* + * The data "model" of a line ignoring line wrapping. + */ +export class LogicalLine { + /** + * @internal + */ + public _data: Uint32Array; + + /** + * @internal + */ + public _combined: {[index: LogicalColumn]: string} = {}; + + /** + * @internal + */ + public _extendedAttrs: {[index: LogicalColumn]: IExtendedAttrs | undefined} = {}; + + public reflowNeeded: boolean = false; + public firstBufferLine: BufferLine | undefined; + public backgroundColor: number = 0; + /** + * Logical "trimmed" length of line. + * Must be no more than this._data.length / 3. */ + public length: number = 0; + + constructor(cols: number = 0, data = new Uint32Array(cols * CELL_SIZE)) { + this._data = data; + } + + /** + * @internal + */ + public resizeData(cols: number): void { + const uint32Cells = cols * CELL_SIZE; + const oldByteLength = this._data.buffer.byteLength; + const neededByteLength = uint32Cells * 4; + if (oldByteLength >= neededByteLength) { + // optimization: avoid alloc and data copy if buffer has enough room + this._data = new Uint32Array(this._data.buffer, 0, uint32Cells); + } else { + // slow path: new alloc and full data copy + const buffer = new ArrayBuffer(Math.max(12 + neededByteLength, (3 * oldByteLength) >> 1)); + const data = new Uint32Array(buffer, 0, uint32Cells); + data.set(this._data); + this._data = data; + } + } + + public getWidth(index: LogicalColumn): number { + return index >= this.length ? NULL_CELL_WIDTH + : this._data[index * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT; + } + + /** usually same as argument, but adjust if wide or at end. + * @internal + */ + public charStart(column: LogicalColumn): number { + return column > this.length ? this.length + : column > 0 && this.getWidth(column - 1) > 1 ? column - 1 + : column; + } + + /** + * Load data at `index` into `cell`. + */ + public loadCell(index: LogicalColumn, cell: ICellData): ICellData { + if (index >= this.length) { + cell.content = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; + cell.fg = 0; + cell.bg = this.backgroundColor; + return cell; + } + const startIndex = index * CELL_SIZE; + cell.content = this._data[startIndex + Cell.CONTENT]; + cell.fg = this._data[startIndex + Cell.FG]; + cell.bg = this._data[startIndex + Cell.BG]; + if (cell.content & Content.IS_COMBINED_MASK) { + cell.combinedData = this._combined[index]; + } + if (cell.bg & BgFlags.HAS_EXTENDED) { + cell.extended = this._extendedAttrs[index]!; + } + return cell; + } + + /** + * Set data at `index` to `cell`. + */ + public setCell(index: LogicalColumn, cell: ICellData): void { + const content = cell.content & (Content.CODEPOINT_MASK|Content.IS_COMBINED_MASK); + this.setCellFromCodepoint(index, content, cell.getWidth(), cell); + if (cell.content & Content.IS_COMBINED_MASK) { + this._combined[index] = cell.combinedData; + } + } + + /** + * Set cell data from input handler. + * Since the input handler see the incoming chars as UTF32 codepoints, + * it gets an optimized access method. + */ + public setCellFromCodepoint(index: LogicalColumn, codePoint: number, width: number, attrs: IAttributeData): void { + if (codePoint === 0 && width === 1 && index >= this.length - 1 && attrs.fg === 0 && attrs.bg === this.backgroundColor) { + if (index === this.length - 1) { + // FIXME should also truncate extendedAttrs and composedData + this.length = index; // this.length - 1; + this.trimLength(); + } + return; + } + if (index >= this.length) { + if ((this as any).xyz) { console.log('-set fill '+index+' to '+this.length);} + this.resizeData(index + 1); + for (let i = this.length; i < index; i++) { + this._data[i * CELL_SIZE + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; + this._data[i * CELL_SIZE + Cell.FG] = 0; + this._data[i * CELL_SIZE + Cell.BG] = this.backgroundColor; + } + this.length = index + 1; + } + if (attrs.bg & BgFlags.HAS_EXTENDED) { + this._extendedAttrs[index] = attrs.extended; + } + this._data[index * CELL_SIZE + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT); + this._data[index * CELL_SIZE + Cell.FG] = attrs.fg; + this._data[index * CELL_SIZE + Cell.BG] = attrs.bg; + } + + /** + * Cleanup underlying array buffer. + * A cleanup will be triggered if the array buffer exceeds the actual used + * memory by a factor of CLEANUP_THRESHOLD. + * Returns 0 or 1 indicating whether a cleanup happened. + */ + public cleanupMemory(threshold: number = 1.3): number { + const cols = this.length; + if (cols * CELL_SIZE * 4 * threshold < this._data.buffer.byteLength) { + const data = new Uint32Array(CELL_SIZE * cols); + data.set(this._data); + this._data = data; + // Remove any cut off combined data + const keys = Object.keys(this._combined); + for (let i = 0; i < keys.length; i++) { + const key = parseInt(keys[i], 10); + if (key >= cols) { + delete this._combined[key]; + } + } + // remove any cut off extended attributes + const extKeys = Object.keys(this._extendedAttrs); + for (let i = 0; i < extKeys.length; i++) { + const key = parseInt(extKeys[i], 10); + if (key >= cols) { + delete this._extendedAttrs[key]; + } + } + return 1; + } + return 0; + } + + /** + * @internal + * + */ + public trimLength(): void { + let index = this.length; + while (index > 0) { + index--; + const content = this._data[index * CELL_SIZE + Cell.CONTENT]; + if (content & Content.HAS_CONTENT_MASK) { + index++; + break; + } + } + if (index < this.length) { + this.length = index; + for (let line = this.firstBufferLine; line; line = line.nextBufferLine) { + if (line.startColumn > index) { + line.startColumn = index; + } + } + // FIXME - possible optimization - trim _data _combinedData _extendedAttrs + } + } + + public copyCellsFrom(src: LogicalLine, srcCol: number, dstCol: number, length: number, applyInReverse: boolean): void { + let cell = applyInReverse ? length - 1 : 0; + const cellIncrement = applyInReverse ? -1 : 1; + for (let todo = length; --todo >= 0; cell += cellIncrement) { + src.loadCell(srcCol + cell, $workCell); + this.setCell(dstCol + cell, $workCell); + } + } + + /** + * Translates the buffer line to a string. + * + * @param startCol The column to start the string (0-based inclusive). + * @param endCol The column to end the string (0-based exclusive). + * @param dataLength ignore _data after dataLength + * @param outColumns if specified, this array will be filled with column numbers such that + * `returnedString[i]` is displayed at `outColumns[i]` column. `outColumns[returnedString.length]` + * is where the character following `returnedString` will be displayed. + * + * When a single cell is translated to multiple UTF-16 code units (e.g. surrogate pair) in the + * returned string, the corresponding entries in `outColumns` will have the same column number. + */ + public translateToString(startCol?: number, endCol?: number, dataLength: number = this.length, outColumns?: number[]): string { + startCol = startCol ?? 0; + endCol = endCol ?? this.length; + if (outColumns) { + outColumns.length = 0; + } + let result = ''; + while (startCol < endCol) { + const content = startCol >= dataLength ? 0 + : this._data[startCol * CELL_SIZE + Cell.CONTENT]; + const cp = content & Content.CODEPOINT_MASK; + const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR; + result += chars; + if (outColumns) { + for (let i = 0; i < chars.length; ++i) { + outColumns.push(startCol); + } + } + startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by at least 1 + } + if (outColumns) { + outColumns.push(startCol); + } + return result; + } +} + /** * Typed array based bufferline implementation. * @@ -53,54 +301,67 @@ const CLEANUP_THRESHOLD = 2; * Used during normal input in `InputHandler` for faster buffer access. * - `setCell` * This method takes a CellData object and stores the data in the buffer. - * Use `CellData.fromCharData` to create the CellData object (e.g. from JS string). + * Use `CellData.fromCharData` to create the CellData object (e.g.0 f from JS string). * * To retrieve data from the buffer use either one of the primitive methods * (if only one particular value is needed) or `loadCell`. For `loadCell` in a loop * memory allocs / GC pressure can be greatly reduced by reusing the CellData object. */ export class BufferLine implements IBufferLine { - protected _data: Uint32Array; - protected _combined: {[index: number]: string} = {}; - protected _extendedAttrs: {[index: number]: IExtendedAttrs | undefined} = {}; + public logicalLine: LogicalLine; + public nextBufferLine: BufferLine | undefined; + + /** Number of logical columns in previous rows. + * Also: logical column number (column number assuming infinitely-wide + * terminal) corresponding to the start of this row. + * If R is the row number (0 for the first BufferLine for a LogicalLine), + * If R is 0 for the previous LogicalBufferLine, R is 1 for first + * then startColumn will *usually* be N*W (where W is the width of + * the terminal in columns) but may be slightly + * different when a wide character at column W-1 must wrap "early". + */ + public startColumn: number = 0; + public length: number; - private _isWrapped: boolean; - public get isWrapped(): boolean { - return this._isWrapped; - } /** + * Last LogicalColumn of this BufferLine. * @internal */ - public setWrapped(isWrapped: boolean): void { - this._isWrapped = isWrapped; + public get validEnd(): LogicalColumn { + return this.nextBufferLine ? this.nextBufferLine.startColumn : this.logicalLine.length; } - constructor(cols: number, fillCellData?: ICellData, isWrapped: boolean = false) { - this._data = new Uint32Array(cols * CELL_SIZE); - const cell = fillCellData ?? CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]); - for (let i = 0; i < cols; ++i) { - this.setCell(i, cell); - } + constructor(cols: number, logicalLine = new LogicalLine(cols)) { + this.logicalLine = logicalLine; this.length = cols; - this._isWrapped = isWrapped; + logicalLine.firstBufferLine ??= this; + } + + public get isWrapped(): boolean { + return this.logicalLine.firstBufferLine !== this; } /** * Get cell data CharData. * @deprecated */ - public get(index: number): CharData { - const content = this._data[index * CELL_SIZE + Cell.CONTENT]; + public get(index: BufferColumn): CharData { + const lline = this.logicalLine; + const lindex: LogicalColumn = index + this.startColumn; + if (lindex >= this.validEnd) { + return [0, '', NULL_CELL_WIDTH, 0]; + } + const content = lline._data[index * CELL_SIZE + Cell.CONTENT]; const cp = content & Content.CODEPOINT_MASK; return [ - this._data[index * CELL_SIZE + Cell.FG], + lline._data[lindex * CELL_SIZE + Cell.FG], (content & Content.IS_COMBINED_MASK) - ? this._combined[index] + ? lline._combined[lindex] : (cp) ? stringFromCodePoint(cp) : '', content >> Content.WIDTH_SHIFT, (content & Content.IS_COMBINED_MASK) - ? this._combined[index].charCodeAt(this._combined[index].length - 1) + ? lline._combined[lindex].charCodeAt(lline._combined[lindex].length - 1) : cp ]; } @@ -110,13 +371,7 @@ export class BufferLine implements IBufferLine { * @deprecated */ public set(index: number, value: CharData): void { - this._data[index * CELL_SIZE + Cell.FG] = value[CHAR_DATA_ATTR_INDEX]; - if (value[CHAR_DATA_CHAR_INDEX].length > 1) { - this._combined[index] = value[1]; - this._data[index * CELL_SIZE + Cell.CONTENT] = index | Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); - } else { - this._data[index * CELL_SIZE + Cell.CONTENT] = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); - } + this.setCell(index, CellData.fromCharData(value)); } /** @@ -124,22 +379,29 @@ export class BufferLine implements IBufferLine { * use these when only one value is needed, otherwise use `loadCell` */ public getWidth(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT; + const lindex: LogicalColumn = index + this.startColumn; + return lindex >= this.validEnd ? NULL_CELL_WIDTH + : this.logicalLine.getWidth(lindex); } /** Test whether content has width. */ public hasWidth(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.WIDTH_MASK; + return this.getWidth(index); } /** Get FG cell component. */ public getFg(index: number): number { - return this._data[index * CELL_SIZE + Cell.FG]; + const lline = this.logicalLine; + const lcolumn = index + this.startColumn; + return lcolumn >= this.validEnd ? 0 : lline._data[lcolumn * CELL_SIZE + Cell.FG]; } /** Get BG cell component. */ public getBg(index: number): number { - return this._data[index * CELL_SIZE + Cell.BG]; + index += this.startColumn; + const lline = this.logicalLine; + return index > lline.length ? lline.backgroundColor + : lline._data[index * CELL_SIZE + Cell.BG]; } /** @@ -148,7 +410,12 @@ export class BufferLine implements IBufferLine { * from real empty cells. */ public hasContent(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK; + index += this.startColumn; + if (index >= this.validEnd) { + return 0; + } + const lline = this.logicalLine; + return lline._data[index * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK; } /** @@ -156,24 +423,40 @@ export class BufferLine implements IBufferLine { * To be in line with `code` in CharData this either returns * a single UTF32 codepoint or the last codepoint of a combined string. */ - public getCodePoint(index: number): number { - const content = this._data[index * CELL_SIZE + Cell.CONTENT]; + public getCodePoint(index: BufferColumn): number { + const lline = this.logicalLine; + const lcolumn: LogicalColumn = index + this.startColumn; + if (lcolumn >= this.validEnd) { + return 0; + } + const content = lline._data[lcolumn * CELL_SIZE + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { - return this._combined[index].charCodeAt(this._combined[index].length - 1); + const combined = lline._combined[lcolumn]; + return combined.charCodeAt(combined.length - 1); } return content & Content.CODEPOINT_MASK; } /** Test whether the cell contains a combined string. */ public isCombined(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.IS_COMBINED_MASK; + const lline = this.logicalLine; + const lcolumn: LogicalColumn = index + this.startColumn; + if (lcolumn >= this.validEnd) { + return 0; + } + return lline._data[lcolumn * CELL_SIZE + Cell.CONTENT] & Content.IS_COMBINED_MASK; } /** Returns the string content of the cell. */ public getString(index: number): string { - const content = this._data[index * CELL_SIZE + Cell.CONTENT]; + const lline = this.logicalLine; + const lcolumn: LogicalColumn = index + this.startColumn; + if (lcolumn >= this.validEnd) { + return ''; + } + const content = lline._data[lcolumn * CELL_SIZE + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { - return this._combined[index]; + return lline._combined[lcolumn]; } if (content & Content.CODEPOINT_MASK) { return stringFromCodePoint(content & Content.CODEPOINT_MASK); @@ -184,7 +467,10 @@ export class BufferLine implements IBufferLine { /** Get state of protected flag. */ public isProtected(index: number): number { - return this._data[index * CELL_SIZE + Cell.BG] & BgFlags.PROTECTED; + const lline = this.logicalLine; + const lcolumn = index + this.startColumn; + return index >= this.length || lcolumn >= lline.length ? 0 + : lline._data[lcolumn * CELL_SIZE + Cell.BG] & BgFlags.PROTECTED; } /** @@ -192,32 +478,32 @@ export class BufferLine implements IBufferLine { * to GC as it significantly reduced the amount of new objects/references needed. */ public loadCell(index: number, cell: ICellData): ICellData { - $startIndex = index * CELL_SIZE; - cell.content = this._data[$startIndex + Cell.CONTENT]; - cell.fg = this._data[$startIndex + Cell.FG]; - cell.bg = this._data[$startIndex + Cell.BG]; - if (cell.content & Content.IS_COMBINED_MASK) { - cell.combinedData = this._combined[index]; - } - if (cell.bg & BgFlags.HAS_EXTENDED) { - cell.extended = this._extendedAttrs[index]!; + const lline = this.logicalLine; + const lcolumn = index + this.startColumn; + const lend = this.validEnd; + if (lcolumn >= lend) { + cell.content = NULL_CELL_CODE | (NULL_CELL_WIDTH << Content.WIDTH_SHIFT); + cell.fg = 0; + if (this.nextBufferLine) { + cell.bg = 0; // FIXME + } else { + cell.bg = lline.backgroundColor; + } + return cell; } - return cell; + return lline.loadCell(lcolumn, cell); } /** * Set data at `index` to `cell`. */ public setCell(index: number, cell: ICellData): void { + // this.logicalLine.setCell(index + this.startColumn, cell); + const content = cell.content & (Content.CODEPOINT_MASK|Content.IS_COMBINED_MASK); + this.setCellFromCodepoint(index, content, cell.getWidth(), cell); if (cell.content & Content.IS_COMBINED_MASK) { - this._combined[index] = cell.combinedData; + this.logicalLine._combined[index + this.startColumn] = cell.combinedData; } - if (cell.bg & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[index] = cell.extended; - } - this._data[index * CELL_SIZE + Cell.CONTENT] = cell.content; - this._data[index * CELL_SIZE + Cell.FG] = cell.fg; - this._data[index * CELL_SIZE + Cell.BG] = cell.bg; } /** @@ -226,12 +512,8 @@ export class BufferLine implements IBufferLine { * it gets an optimized access method. */ public setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void { - if (attrs.bg & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[index] = attrs.extended; - } - this._data[index * CELL_SIZE + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT); - this._data[index * CELL_SIZE + Cell.FG] = attrs.fg; - this._data[index * CELL_SIZE + Cell.BG] = attrs.bg; + this.logicalLine.setCellFromCodepoint(index + this.startColumn, + codePoint, width, attrs); } /** @@ -241,16 +523,24 @@ export class BufferLine implements IBufferLine { * by the previous `setDataFromCodePoint` call, we can omit it here. */ public addCodepointToCell(index: number, codePoint: number, width: number): void { - let content = this._data[index * CELL_SIZE + Cell.CONTENT]; + const lline = this.logicalLine; + const lcolumn = index + this.startColumn; + if (lcolumn >= this.validEnd) { + // should not happen - we actually have no data in the cell yet + // simply set the data in the cell buffer with a width of 1 + this.setCellFromCodepoint(index, codePoint, 1, CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE])); + return; + } + let content = lline._data[lcolumn * CELL_SIZE + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { // we already have a combined string, simply add - this._combined[index] += stringFromCodePoint(codePoint); + lline._combined[lcolumn] += stringFromCodePoint(codePoint); } else { if (content & Content.CODEPOINT_MASK) { // normal case for combining chars: // - move current leading char + new one into combined string // - set combined flag - this._combined[index] = stringFromCodePoint(content & Content.CODEPOINT_MASK) + stringFromCodePoint(codePoint); + lline._combined[lcolumn] = stringFromCodePoint(content & Content.CODEPOINT_MASK) + stringFromCodePoint(codePoint); content &= ~Content.CODEPOINT_MASK; // set codepoint in buffer to 0 content |= Content.IS_COMBINED_MASK; } else { @@ -263,7 +553,7 @@ export class BufferLine implements IBufferLine { content &= ~Content.WIDTH_MASK; content |= width << Content.WIDTH_SHIFT; } - this._data[index * CELL_SIZE + Cell.CONTENT] = content; + lline._data[lcolumn * CELL_SIZE + Cell.CONTENT] = content; } public insertCells(pos: number, n: number, fillCellData: ICellData): void { @@ -352,52 +642,50 @@ export class BufferLine implements IBufferLine { } /** - * Resize BufferLine to `cols` filling excess cells with `fillCellData`. + * Resize to `cols` filling excess cells with `fillCellData`. * The underlying array buffer will not change if there is still enough space * to hold the new buffer line data. * Returns a boolean indicating, whether a `cleanupMemory` call would free * excess memory (true after shrinking > CLEANUP_THRESHOLD). + * Assumes single unwrapped line. + * @deprecated only used in tests */ public resize(cols: number, fillCellData: ICellData): boolean { + const logical = this.logicalLine; + if (logical.firstBufferLine !== this || this.nextBufferLine) { + throw new Error('invalid call to resize'); + } if (cols === this.length) { - return this._data.length * 4 * CLEANUP_THRESHOLD < this._data.buffer.byteLength; + return logical._data.length * 4 * CLEANUP_THRESHOLD < logical._data.buffer.byteLength; } const uint32Cells = cols * CELL_SIZE; if (cols > this.length) { - if (this._data.buffer.byteLength >= uint32Cells * 4) { - // optimization: avoid alloc and data copy if buffer has enough room - this._data = new Uint32Array(this._data.buffer, 0, uint32Cells); - } else { - // slow path: new alloc and full data copy - const data = new Uint32Array(uint32Cells); - data.set(this._data); - this._data = data; - } + logical.resizeData(cols); for (let i = this.length; i < cols; ++i) { this.setCell(i, fillCellData); } } else { // optimization: just shrink the view on existing buffer - this._data = this._data.subarray(0, uint32Cells); + logical._data = logical._data.subarray(0, cols * CELL_SIZE); // Remove any cut off combined data - const keys = Object.keys(this._combined); + const keys = Object.keys(logical._combined); for (let i = 0; i < keys.length; i++) { const key = parseInt(keys[i], 10); if (key >= cols) { - delete this._combined[key]; + delete logical._combined[key]; } } // remove any cut off extended attributes - const extKeys = Object.keys(this._extendedAttrs); + const extKeys = Object.keys(logical._extendedAttrs); for (let i = 0; i < extKeys.length; i++) { const key = parseInt(extKeys[i], 10); if (key >= cols) { - delete this._extendedAttrs[key]; + delete logical._extendedAttrs[key]; } } } this.length = cols; - return uint32Cells * 4 * CLEANUP_THRESHOLD < this._data.buffer.byteLength; + return uint32Cells * 4 * CLEANUP_THRESHOLD < logical._data.buffer.byteLength; } /** @@ -407,13 +695,7 @@ export class BufferLine implements IBufferLine { * Returns 0 or 1 indicating whether a cleanup happened. */ public cleanupMemory(): number { - if (this._data.length * 4 * CLEANUP_THRESHOLD < this._data.buffer.byteLength) { - const data = new Uint32Array(this._data.length); - data.set(this._data); - this._data = data; - return 1; - } - return 0; + return this.logicalLine.cleanupMemory(CLEANUP_THRESHOLD); } /** fill a line with fillCharData */ @@ -427,96 +709,48 @@ export class BufferLine implements IBufferLine { } return; } - this._combined = {}; - this._extendedAttrs = {}; + const lline = this.logicalLine; + if (lline.firstBufferLine === this && ! this.nextBufferLine) { + lline._combined = {}; + lline._extendedAttrs = {}; + } for (let i = 0; i < this.length; ++i) { this.setCell(i, fillCellData); } } - /** alter to a full copy of line */ + /** alter to a full copy of line + * @deprecated only used in a few tests + */ public copyFrom(line: BufferLine): void { - if (this.length !== line.length) { - this._data = new Uint32Array(line._data); - } else { - // use high speed copy if lengths are equal - this._data.set(line._data); - } + this.copyCellsFrom(line, 0, 0, this.length, false); this.length = line.length; - this._combined = {}; - for (const el in line._combined) { - this._combined[el] = line._combined[el]; - } - this._extendedAttrs = {}; - for (const el in line._extendedAttrs) { - this._extendedAttrs[el] = line._extendedAttrs[el]; - } - this._isWrapped = line._isWrapped; - } - - /** create a new clone */ - public clone(): IBufferLine { - const newLine = new BufferLine(0); - newLine._data = new Uint32Array(this._data); - newLine.length = this.length; - for (const el in this._combined) { - newLine._combined[el] = this._combined[el]; - } - for (const el in this._extendedAttrs) { - newLine._extendedAttrs[el] = this._extendedAttrs[el]; - } - newLine._isWrapped = this._isWrapped; - return newLine; } - public getTrimmedLength(): number { - for (let i = this.length - 1; i >= 0; --i) { - if ((this._data[i * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK)) { - return i + (this._data[i * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT); + public getTrimmedLength(noBg: boolean = false): number { + const logicalLine = this.logicalLine; + const startColumn = this.startColumn; + const data = logicalLine._data; + for (let i = this.validEnd; --i >= startColumn; ) { + if ((data[i * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK) + || (noBg && (data[i * CELL_SIZE + Cell.BG] & Attributes.CM_MASK))) { + i += data[i * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT; + return i - startColumn; } } - return 0; + return startColumn; } public getNoBgTrimmedLength(): number { - for (let i = this.length - 1; i >= 0; --i) { - if ((this._data[i * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK) || (this._data[i * CELL_SIZE + Cell.BG] & Attributes.CM_MASK)) { - return i + (this._data[i * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT); - } + if (this.logicalLine.backgroundColor) { + return this.length; } - return 0; + return this.getTrimmedLength(true); } public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void { - const srcData = src._data; - if (applyInReverse) { - for (let cell = length - 1; cell >= 0; cell--) { - for (let i = 0; i < CELL_SIZE; i++) { - this._data[(destCol + cell) * CELL_SIZE + i] = srcData[(srcCol + cell) * CELL_SIZE + i]; - } - if (srcData[(srcCol + cell) * CELL_SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[destCol + cell] = src._extendedAttrs[srcCol + cell]; - } - } - } else { - for (let cell = 0; cell < length; cell++) { - for (let i = 0; i < CELL_SIZE; i++) { - this._data[(destCol + cell) * CELL_SIZE + i] = srcData[(srcCol + cell) * CELL_SIZE + i]; - } - if (srcData[(srcCol + cell) * CELL_SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[destCol + cell] = src._extendedAttrs[srcCol + cell]; - } - } - } - - // Move any combined data over as needed, FIXME: repeat for extended attrs - const srcCombinedKeys = Object.keys(src._combined); - for (let i = 0; i < srcCombinedKeys.length; i++) { - const key = parseInt(srcCombinedKeys[i], 10); - if (key >= srcCol) { - this._combined[key - srcCol + destCol] = src._combined[key]; - } - } + this.logicalLine.copyCellsFrom(src.logicalLine, srcCol + src.startColumn, + destCol + this.startColumn, length, applyInReverse); } /** @@ -538,25 +772,121 @@ export class BufferLine implements IBufferLine { if (trimRight) { endCol = Math.min(endCol, this.getTrimmedLength()); } - if (outColumns) { - outColumns.length = 0; + const lline = this.logicalLine; + const lineStart = this.startColumn; + const validEnd = this.validEnd; + startCol += lineStart; + endCol += lineStart; + const paddingNeeded = trimRight || endCol <= validEnd ? 0 + : endCol - validEnd; + const result = lline.translateToString(startCol, endCol, endCol - paddingNeeded, outColumns); + if (outColumns && lineStart) { + for (let i = outColumns.length; --i >= 0; ) { + outColumns[i] -= lineStart; + } } - let result = ''; - while (startCol < endCol) { - const content = this._data[startCol * CELL_SIZE + Cell.CONTENT]; - const cp = content & Content.CODEPOINT_MASK; - const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR; - result += chars; - if (outColumns) { - for (let i = 0; i < chars.length; ++i) { - outColumns.push(startCol); + return result; + } + + public getPreviousLine(): BufferLine | undefined { + for (let row = this.logicalLine.firstBufferLine; ;) { + if (! row) { + return undefined; + } + const next = row.nextBufferLine; + if (next === this) { + return row; + } + row = next; + } + } + + public eraseRight(index: BufferColumn): void { + const lineStart = this.startColumn; + const lineEnd = lineStart + index; + const lline = this.logicalLine; + if (this.nextBufferLine) { + const oldEnd = this.nextBufferLine.startColumn; + const count = oldEnd - lineEnd; + if (count > 0) { + let next: BufferLine | undefined = this; + for (;;) { + next = next.nextBufferLine; + if (! next) break; + next.startColumn -= count; } + lline.copyCellsFrom(lline, oldEnd, lineEnd, lline.length - oldEnd, false); + lline.length -= count; + } + } else { + if (lineEnd < lline.length) { + lline.length = lineEnd; } - startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by at least 1 } - if (outColumns) { - outColumns.push(startCol); + } + + public setWrapped(previousLine: BufferLine): BufferLine { + const column = previousLine.startColumn + previousLine.length; + const logicalLine = previousLine.logicalLine; + const oldLogical = this.logicalLine; + logicalLine.resizeData(column + oldLogical.length); + const newData = logicalLine._data; + for (let i = logicalLine.length; i < column + oldLogical.length; i++) { + newData[i * CELL_SIZE + Cell.CONTENT] = 0; + newData[i * CELL_SIZE + Cell.FG] = 0; + newData[i * CELL_SIZE + Cell.BG] = logicalLine.backgroundColor; + } + logicalLine.copyCellsFrom(oldLogical, 0, column, oldLogical.length, false); + /* + const oldData = oldLogical._data; + for (let i = 0; i < oldLogical.length; i++) { + const oldIndex = i * CELL_SIZE; + const newIndex = (column + i) * CELL_SIZE + const content = oldData[oldIndex + Cell.CONTENT]; + const fg = oldData[oldIndex + Cell.FG]; + const bg = oldData[oldIndex + Cell.BG]; + newData[newIndex + Cell.CONTENT] = content; + newData[newIndex + Cell.FG] = fg; + newData[newIndex + Cell.BG] = bg; + if (content & Content.IS_COMBINED_MASK) { + lprevious._combined[column + i] = oldLogical._combined[i]; + } + if (bg & BgFlags.HAS_EXTENDED) { + lprevious._extendedAttrs[column + i] = oldLogical._extendedAttrs[i]; + } } - return result; + */ + + logicalLine.length = column + oldLogical.length; + if ((globalThis as any).xyz) console.log('- llen='+column+'+'+oldLogical.length); + logicalLine.backgroundColor = oldLogical.backgroundColor; + previousLine.nextBufferLine = this; + for (let line: BufferLine | undefined = this; line; line = line.nextBufferLine) { + line.startColumn += column; + line.logicalLine = logicalLine; + } + return this; + + } + + public asUnwrapped(prevRow: BufferLine): LogicalLine { + const oldStartColumn = this.startColumn; + prevRow.nextBufferLine = undefined; + const oldLine = prevRow.logicalLine; + const cell = new CellData(); + this.loadCell(oldStartColumn, cell); + const newLength = oldLine.length - oldStartColumn; + const newLogical = new LogicalLine(newLength); + newLogical.copyCellsFrom(oldLine, oldStartColumn, 0, newLength, false); + newLogical.firstBufferLine = this; + for (let nextRow: BufferLine | undefined = this; nextRow; nextRow = nextRow.nextBufferLine) { + nextRow.startColumn -= oldStartColumn; + nextRow.logicalLine = newLogical; + } + oldLine.length = oldStartColumn; + oldLine.trimLength(); + // FIXME truncate/resize + newLogical.backgroundColor = oldLine.backgroundColor; + return newLogical; } } diff --git a/src/common/buffer/BufferReflow.test.ts b/src/common/buffer/BufferReflow.test.ts index b351b89c42..422231c4e8 100644 --- a/src/common/buffer/BufferReflow.test.ts +++ b/src/common/buffer/BufferReflow.test.ts @@ -5,7 +5,71 @@ import { assert } from 'chai'; import { BufferLine } from 'common/buffer/BufferLine'; import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE } from 'common/buffer/Constants'; -import { reflowSmallerGetNewLineLengths } from 'common/buffer/BufferReflow'; + +/** + * Gets the new line lengths for a given wrapped line. The purpose of this function it to pre- + * compute the wrapping points since wide characters may need to be wrapped onto the following line. + * This function will return an array of numbers of where each line wraps to, the resulting array + * will only contain the values `newCols` (when the line does not end with a wide character) and + * `newCols - 1` (when the line does end with a wide character), except for the last value which + * will contain the remaining items to fill the line. + * + * Calling this with a `newCols` value of `1` will lock up. + * + * This function is now only used for testing. + * + * @param wrappedLines The wrapped lines to evaluate. + * @param oldCols The columns before resize. + * @param newCols The columns after resize. + */ +function reflowSmallerGetNewLineLengths(wrappedLines: BufferLine[], oldCols: number, newCols: number): number[] { + const newLineLengths: number[] = []; + const cellsNeeded = wrappedLines.map((l, i) => getWrappedLineTrimmedLength(wrappedLines, i, oldCols)).reduce((p, c) => p + c); + + // Use srcCol and srcLine to find the new wrapping point, use that to get the cellsAvailable and + // linesNeeded + let srcCol = 0; + let srcLine = 0; + let cellsAvailable = 0; + while (cellsAvailable < cellsNeeded) { + if (cellsNeeded - cellsAvailable < newCols) { + // Add the final line and exit the loop + newLineLengths.push(cellsNeeded - cellsAvailable); + break; + } + srcCol += newCols; + const oldTrimmedLength = getWrappedLineTrimmedLength(wrappedLines, srcLine, oldCols); + if (srcCol > oldTrimmedLength) { + srcCol -= oldTrimmedLength; + srcLine++; + } + const endsWithWide = wrappedLines[srcLine].getWidth(srcCol - 1) === 2; + if (endsWithWide) { + srcCol--; + } + const lineLength = endsWithWide ? newCols - 1 : newCols; + newLineLengths.push(lineLength); + cellsAvailable += lineLength; + } + + return newLineLengths; +} + +function getWrappedLineTrimmedLength(lines: BufferLine[], i: number, cols: number): number { + // If this is the last row in the wrapped line, get the actual trimmed length + if (i === lines.length - 1) { + return lines[i].getTrimmedLength(); + } + // Detect whether the following line starts with a wide character and the end of the current line + // is null, if so then we can be pretty sure the null character should be excluded from the line + // length] + const endsInNull = !(lines[i].hasContent(cols - 1)) && lines[i].getWidth(cols - 1) === 1; + const followingLineStartsWithWide = lines[i + 1].getWidth(0) === 2; + if (endsInNull && followingLineStartsWithWide) { + return cols - 1; + } + return cols; +} describe('BufferReflow', () => { describe('reflowSmallerGetNewLineLengths', () => { @@ -63,7 +127,7 @@ describe('BufferReflow', () => { line1.set(3, [0, '语', 2, '语'.charCodeAt(0)]); line1.set(4, [0, '', 0, 0]); line1.set(5, [0, 'b', 1, 'b'.charCodeAt(0)]); - const line2 = new BufferLine(6, undefined, true); + const line2 = new BufferLine(6, undefined); line2.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]); line2.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]); line2.set(2, [0, '', 0, 0]); diff --git a/src/common/buffer/BufferReflow.ts b/src/common/buffer/BufferReflow.ts index 44aa0976fe..9822ae261d 100644 --- a/src/common/buffer/BufferReflow.ts +++ b/src/common/buffer/BufferReflow.ts @@ -5,109 +5,13 @@ import { BufferLine } from 'common/buffer/BufferLine'; import { CircularList } from 'common/CircularList'; -import { IBufferLine, ICellData } from 'common/Types'; +import { IBufferLine } from 'common/Types'; export interface INewLayoutResult { layout: number[]; countRemoved: number; } -/** - * Evaluates and returns indexes to be removed after a reflow larger occurs. Lines will be removed - * when a wrapped line unwraps. - * @param lines The buffer lines. - * @param oldCols The columns before resize - * @param newCols The columns after resize. - * @param bufferAbsoluteY The absolute y position of the cursor (baseY + cursorY). - * @param nullCell The cell data to use when filling in empty cells. - * @param reflowCursorLine Whether to reflow the line containing the cursor. - */ -export function reflowLargerGetLinesToRemove(lines: CircularList, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData, reflowCursorLine: boolean): number[] { - // Gather all BufferLines that need to be removed from the Buffer here so that they can be - // batched up and only committed once - const toRemove: number[] = []; - - for (let y = 0; y < lines.length - 1; y++) { - // Check if this row is wrapped - let i = y; - let nextLine = lines.get(++i) as BufferLine; - if (!nextLine.isWrapped) { - continue; - } - - // Check how many lines it's wrapped for - const wrappedLines: BufferLine[] = [lines.get(y) as BufferLine]; - while (i < lines.length && nextLine.isWrapped) { - wrappedLines.push(nextLine); - nextLine = lines.get(++i) as BufferLine; - } - - if (!reflowCursorLine) { - // If these lines contain the cursor don't touch them, the program will handle fixing up - // wrapped lines with the cursor - if (bufferAbsoluteY >= y && bufferAbsoluteY < i) { - y += wrappedLines.length - 1; - continue; - } - } - - // Copy buffer data to new locations - let destLineIndex = 0; - let destCol = getWrappedLineTrimmedLength(wrappedLines, destLineIndex, oldCols); - let srcLineIndex = 1; - let srcCol = 0; - while (srcLineIndex < wrappedLines.length) { - const srcTrimmedTineLength = getWrappedLineTrimmedLength(wrappedLines, srcLineIndex, oldCols); - const srcRemainingCells = srcTrimmedTineLength - srcCol; - const destRemainingCells = newCols - destCol; - const cellsToCopy = Math.min(srcRemainingCells, destRemainingCells); - - wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol, destCol, cellsToCopy, false); - - destCol += cellsToCopy; - if (destCol === newCols) { - destLineIndex++; - destCol = 0; - } - srcCol += cellsToCopy; - if (srcCol === srcTrimmedTineLength) { - srcLineIndex++; - srcCol = 0; - } - - // Make sure the last cell isn't wide, if it is copy it to the current dest - if (destCol === 0 && destLineIndex !== 0) { - if (wrappedLines[destLineIndex - 1].getWidth(newCols - 1) === 2) { - wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[destLineIndex - 1], newCols - 1, destCol++, 1, false); - // Null out the end of the last row - wrappedLines[destLineIndex - 1].setCell(newCols - 1, nullCell); - } - } - } - - // Clear out remaining cells or fragments could remain; - wrappedLines[destLineIndex].replaceCells(destCol, newCols, nullCell); - - // Work backwards and remove any rows at the end that only contain null cells - let countToRemove = 0; - for (let i = wrappedLines.length - 1; i > 0; i--) { - if (i > destLineIndex || wrappedLines[i].getTrimmedLength() === 0) { - countToRemove++; - } else { - break; - } - } - - if (countToRemove > 0) { - toRemove.push(y + wrappedLines.length - countToRemove); // index - toRemove.push(countToRemove); - } - - y += wrappedLines.length - 1; - } - return toRemove; -} - /** * Creates and return the new layout for lines given an array of indexes to be removed. * @param lines The buffer lines. @@ -162,53 +66,6 @@ export function reflowLargerApplyNewLayout(lines: CircularList, new lines.length = newLayout.length; } -/** - * Gets the new line lengths for a given wrapped line. The purpose of this function it to pre- - * compute the wrapping points since wide characters may need to be wrapped onto the following line. - * This function will return an array of numbers of where each line wraps to, the resulting array - * will only contain the values `newCols` (when the line does not end with a wide character) and - * `newCols - 1` (when the line does end with a wide character), except for the last value which - * will contain the remaining items to fill the line. - * - * Calling this with a `newCols` value of `1` will lock up. - * - * @param wrappedLines The wrapped lines to evaluate. - * @param oldCols The columns before resize. - * @param newCols The columns after resize. - */ -export function reflowSmallerGetNewLineLengths(wrappedLines: BufferLine[], oldCols: number, newCols: number): number[] { - const newLineLengths: number[] = []; - const cellsNeeded = wrappedLines.map((l, i) => getWrappedLineTrimmedLength(wrappedLines, i, oldCols)).reduce((p, c) => p + c); - - // Use srcCol and srcLine to find the new wrapping point, use that to get the cellsAvailable and - // linesNeeded - let srcCol = 0; - let srcLine = 0; - let cellsAvailable = 0; - while (cellsAvailable < cellsNeeded) { - if (cellsNeeded - cellsAvailable < newCols) { - // Add the final line and exit the loop - newLineLengths.push(cellsNeeded - cellsAvailable); - break; - } - srcCol += newCols; - const oldTrimmedLength = getWrappedLineTrimmedLength(wrappedLines, srcLine, oldCols); - if (srcCol > oldTrimmedLength) { - srcCol -= oldTrimmedLength; - srcLine++; - } - const endsWithWide = wrappedLines[srcLine].getWidth(srcCol - 1) === 2; - if (endsWithWide) { - srcCol--; - } - const lineLength = endsWithWide ? newCols - 1 : newCols; - newLineLengths.push(lineLength); - cellsAvailable += lineLength; - } - - return newLineLengths; -} - export function getWrappedLineTrimmedLength(lines: BufferLine[], i: number, cols: number): number { // If this is the last row in the wrapped line, get the actual trimmed length if (i === lines.length - 1) { diff --git a/src/common/buffer/CellData.ts b/src/common/buffer/CellData.ts index 43c4c594b0..892e2d7f36 100644 --- a/src/common/buffer/CellData.ts +++ b/src/common/buffer/CellData.ts @@ -88,7 +88,9 @@ export class CellData extends AttributeData implements ICellData { this.content = Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); } } - /** Get data as CharData. */ + /** Get data as CharData. + * @deprecated + */ public getAsCharData(): CharData { return [this.fg, this.getChars(), this.getWidth(), this.getCode()]; } diff --git a/src/common/buffer/Constants.ts b/src/common/buffer/Constants.ts index 5ce075cf78..b37c0f3a81 100644 --- a/src/common/buffer/Constants.ts +++ b/src/common/buffer/Constants.ts @@ -4,6 +4,7 @@ */ export const DEFAULT_COLOR = 0; +// Only used for testing - move to TestUtils? export const DEFAULT_ATTR = (0 << 18) | (DEFAULT_COLOR << 9) | (256 << 0); export const DEFAULT_EXT = 0; diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts index a7e7321f2f..11e180ff0b 100644 --- a/src/common/buffer/Types.ts +++ b/src/common/buffer/Types.ts @@ -11,10 +11,30 @@ export type BufferIndex = [number, number]; export interface IBuffer { readonly lines: ICircularList; + /** Number of rows above top visible row. + * Similar to scrollTop (i.e. affected by scrollbar), but in rows. + */ ydisp: number; + /** Number of rows in the scrollback buffer, above the home row. */ ybase: number; + + /** Row number relative to the "home" row, zero-origin. + * This is the row number changed/reported by cursor escape sequences, + * except that y is 0-origin: y=0 when we're at the home row. + * Currently assumed to be >= 0, but future may allow negative - i.e. + * in scroll-back area, as long as ybase+y >= 0. + */ y: number; + + /** Column number, zero-origin. + * Valid range is 0 through C (inclusive), if C is terminal width in columns. + * The first (left-most) column is 0. + * The right-most column is either C-1 (before the right-most column, and + * ready to write in it), or C (after the right-most column, having written + * to it, and ready to wrap). DSR 6 returns C (1-origin) in either case, + */ x: number; + tabs: any; scrollBottom: number; scrollTop: number; diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index e71bc04ab1..da3bbecaeb 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -6,10 +6,10 @@ import { Disposable } from 'common/Lifecycle'; import { IAttributeData, IBufferLine } from 'common/Types'; import { BufferSet } from 'common/buffer/BufferSet'; -import { BufferLine } from 'common/buffer/BufferLine'; import { IBuffer, IBufferSet } from 'common/buffer/Types'; import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services'; import { Emitter } from 'common/Event'; +import { BufferLine, LogicalLine } from 'common/buffer/BufferLine'; export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars export const MINIMUM_ROWS = 1; @@ -67,17 +67,21 @@ export class BufferService extends Disposable implements IBufferService { */ public scroll(eraseAttr: IAttributeData, isWrapped: boolean = false): void { const buffer = this.buffer; - - let newLine: IBufferLine | undefined; - newLine = this._cachedBlankLine; - if (!newLine || newLine.length !== this.cols || newLine.getFg(0) !== eraseAttr.fg || newLine.getBg(0) !== eraseAttr.bg) { - newLine = buffer.getBlankLine(eraseAttr, isWrapped); - this._cachedBlankLine = newLine; - } - (newLine as BufferLine).setWrapped(isWrapped); - const topRow = buffer.ybase + buffer.scrollTop; const bottomRow = buffer.ybase + buffer.scrollBottom; + const oldLine = buffer.lines.get(bottomRow) as BufferLine; + let lline: LogicalLine; + if (isWrapped) { + lline = oldLine.logicalLine; + } else { + lline = new LogicalLine(0); + } + const newLine = new BufferLine(this.cols, lline); + if (isWrapped && oldLine) { + oldLine.nextBufferLine = newLine; + newLine.startColumn = lline.length; + } + lline.backgroundColor = eraseAttr.bg; if (buffer.scrollTop === 0) { // Determine whether the buffer is going to be trimmed after insertion. @@ -85,13 +89,9 @@ export class BufferService extends Disposable implements IBufferService { // Insert the line using the fastest method if (bottomRow === buffer.lines.length - 1) { - if (willBufferBeTrimmed) { - buffer.lines.recycle().copyFrom(newLine); - } else { - buffer.lines.push(newLine.clone()); - } + buffer.lines.push(newLine); } else { - buffer.lines.splice(bottomRow + 1, 0, newLine.clone()); + buffer.lines.splice(bottomRow + 1, 0, newLine); } // Only adjust ybase and ydisp when the buffer is not trimmed @@ -113,7 +113,7 @@ export class BufferService extends Disposable implements IBufferService { // scrollback, instead we can just shift them in-place. const scrollRegionHeight = bottomRow - topRow + 1 /* as it's zero-based */; buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1); - buffer.lines.set(bottomRow, newLine.clone()); + buffer.lines.set(bottomRow, newLine); } // Move the viewport to the bottom of the buffer unless the user is From b4696162353af198956b731240ebdd5ca0db8040 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Sun, 7 Jun 2026 13:32:46 -0700 Subject: [PATCH 04/15] Un-remove whitespace to match upsteam. --- src/common/buffer/Buffer.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index ef079e8a5b..e6f8ae1750 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -364,12 +364,14 @@ export class Buffer extends Disposable implements IBuffer { if (!nextLine || !nextLine.isWrapped && nextLine.getTrimmedLength() <= newCols) { continue; } + // Gather wrapped lines and adjust y to be the starting line const wrappedLines: BufferLine[] = [nextLine]; while (nextLine.isWrapped && y > 0) { nextLine = this.lines.get(--y) as BufferLine; wrappedLines.unshift(nextLine); } + if (!reflowCursorLine) { // If these lines contain the cursor don't touch them, the program will handle fixing up // wrapped lines with the cursor From b1edb574c5846a4df0ea673f5c55f7cd45dd2b08 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Sun, 16 Aug 2026 11:13:09 -0700 Subject: [PATCH 05/15] Optimize _resizeData to need fewer (re-)allocations --- src/common/buffer/BufferLine.ts | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index 71d98492b9..11deef2ba1 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -67,6 +67,8 @@ export interface IBufferLineStringCache { touch?(): void; } +const EMPTY_DATA = new Uint32Array(0); + /* * The data "model" of a line ignoring line wrapping. */ @@ -75,7 +77,7 @@ export class LogicalLine implements ILogicalLine { * @internal */ public _data: Uint32Array; - /** Sparse cache; only rea`d when `IS_COMBINED_MASK` is set in `_data`. */ + /** Sparse cache; only read when `IS_COMBINED_MASK` is set in `_data`. */ public _combined: {[index: LogicalColumn]: string} = {}; /** * @internal @@ -91,7 +93,7 @@ export class LogicalLine implements ILogicalLine { */ public length: number = 0; - constructor(cols: number = 0, data = new Uint32Array(cols * Constants.CELL_INDICIES)) { + constructor(cols: number = 0, data = cols === 0 ? EMPTY_DATA : new Uint32Array(cols * Constants.CELL_INDICIES)) { this._data = data; } @@ -100,15 +102,11 @@ export class LogicalLine implements ILogicalLine { */ public resizeData(cols: number): void { const uint32Cells = cols * Constants.CELL_INDICIES; - const oldByteLength = this._data.buffer.byteLength; - const neededByteLength = uint32Cells * 4; - if (oldByteLength >= neededByteLength) { - // optimization: avoid alloc and data copy if buffer has enough room - this._data = new Uint32Array(this._data.buffer, 0, uint32Cells); - } else { - // slow path: new alloc and full data copy - const buffer = new ArrayBuffer(Math.max(12 + neededByteLength, (3 * oldByteLength) >> 1)); - const data = new Uint32Array(buffer, 0, uint32Cells); + const oldLength = this._data.length; + if (uint32Cells >= oldLength) { + // increase by at least 50% + const newLength = Math.max(uint32Cells + 60, (3 * oldLength) >> 1); + const data = new Uint32Array(newLength); data.set(this._data); this._data = data; } From ce06560125c7b777aad1ca3d424ff0bf02191b4b Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Mon, 24 Aug 2026 11:17:29 -0700 Subject: [PATCH 06/15] New LineBuffer.setCellsFromCodepoints This is used by InputHandler.print to "batch" multiple characters. --- src/common/InputHandler.ts | 129 ++++++++++++++++----------- src/common/buffer/Buffer.ts | 1 + src/common/buffer/BufferLine.ts | 37 ++++++++ src/common/services/BufferService.ts | 2 +- 4 files changed, 114 insertions(+), 55 deletions(-) diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index c6426adaa5..2a4803a1bf 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -514,16 +514,20 @@ export class InputHandler extends Disposable implements IInputHandler { } } + /** + * Write printable characters. + * Character to write are code points stored in data.slice(start, end). + * Note that data.slice(start, end) might be modified in place. + */ public print(data: Uint32Array, start: number, end: number): void { let code: number; - let chWidth: number; const charset = this._charsetService.charset; const screenReaderMode = this._optionsService.rawOptions.screenReaderMode; const cols = this._bufferService.cols; const wraparoundMode = this._coreService.decPrivateModes.wraparound; const insertMode = this._coreService.modes.insertMode; const curAttr = this._curAttrData; - let bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y); + let bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y) as BufferLine; // Defensive check: bufferRow can be undefined if a resize occurred mid-write due to async // scheduling gaps in WriteBuffer. See https://github.com/xtermjs/xterm.js/issues/5597 @@ -539,43 +543,79 @@ export class InputHandler extends Disposable implements IInputHandler { } let precedingJoinState = this._parser.precedingJoinState; - for (let pos = start; pos < end; ++pos) { - code = data[pos]; - - // Soft hyphen's (U+00AD) behavior is ambiguous and differs across terminals. We opt to treat - // it as a zero-width hint to text layout engines and simply ignore it. - if (code === 0xAD) { - continue; - } + let pendingStart = -1; + let pendingCols = 0; + for (let pos = start; ; ++pos) { + let oldWidth; + let chWidth; + let shouldJoin; + let overflowing; + if (pos < end) { + code = data[pos]; + + // Soft hyphen's (U+00AD) behavior is ambiguous and differs across terminals. + // We opt to treat it as a zero-width hint to text layout engines and simply ignore it. + if (code === 0xAD) { + // Not very efficient, but simple. + pendingStart < 0 || data.copyWithin(pos, pos + 1, end); + continue; + } - // get charset replacement character - // charset is only defined for ASCII, therefore we only - // search for an replacement char if code < 127 - if (code < 127 && charset) { - const ch = charset[String.fromCharCode(code)]; - if (ch) { - code = ch.charCodeAt(0); + // get charset replacement character + // charset is only defined for ASCII, therefore we only + // search for an replacement char if code < 127 + if (code < 127 && charset) { + const ch = charset[String.fromCharCode(code)]; + if (ch) { + code = ch.charCodeAt(0); + data[pos] = code; + } } - } - const currentInfo = this._unicodeService.charProperties(code, precedingJoinState); - chWidth = UnicodeService.extractWidth(currentInfo); - const shouldJoin = UnicodeService.extractShouldJoin(currentInfo); - const oldWidth = shouldJoin ? UnicodeService.extractWidth(precedingJoinState) : 0; - precedingJoinState = currentInfo; + const currentInfo = this._unicodeService.charProperties(code, precedingJoinState); + chWidth = UnicodeService.extractWidth(currentInfo); + shouldJoin = UnicodeService.extractShouldJoin(currentInfo); + oldWidth = shouldJoin ? UnicodeService.extractWidth(precedingJoinState) : 0; + precedingJoinState = currentInfo; - if (screenReaderMode) { - this._onA11yChar.fire(stringFromCodePoint(code)); + if (screenReaderMode) { + this._onA11yChar.fire(stringFromCodePoint(code)); + } + const linkId = this._getCurrentLinkId(); + if (linkId) { + this._oscLinkService.addLineToLink(linkId, this._activeBuffer.ybase + this._activeBuffer.y); + } + overflowing = this._activeBuffer.x + chWidth - oldWidth > cols; + } else { + oldWidth = 0; + chWidth = 0; + code = -1; + shouldJoin = false; } - const linkId = this._getCurrentLinkId(); - if (linkId) { - this._oscLinkService.addLineToLink(linkId, this._activeBuffer.ybase + this._activeBuffer.y); + if (pendingStart >= 0 && (code < 0 || overflowing || shouldJoin)) { + // insert mode: move characters to right + if (insertMode) { + // right shift cells according to the width + bufferRow.insertCells(this._activeBuffer.x - pendingCols, pendingCols, this._activeBuffer.getNullCell(curAttr)); + // test last cell - since the last cell has only room for + // a halfwidth char any fullwidth shifted there is lost + // and will be set to empty cell + if (bufferRow.getWidth(cols - 1) === 2) { + bufferRow.setCellFromCodepoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr); + } + } + bufferRow.setCellsFromCodepoints(this._activeBuffer.x - pendingCols, pendingCols, data, pendingStart, pos, curAttr); + pendingStart = -1; + pendingCols = 0; + } + if (code < 0) { + break; } // goto next line if ch would overflow // NOTE: To avoid costly width checks here, // the terminal does not allow a cols < 2. - if (this._activeBuffer.x + chWidth - oldWidth > cols) { + if (overflowing) { // autowrap - DECAWM // automatically wraps to the beginning of the next line if (wraparoundMode) { @@ -595,7 +635,7 @@ export class InputHandler extends Disposable implements IInputHandler { this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, true); } // row changed, get it again - bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y); + bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y) as BufferLine if (!bufferRow) { return; } @@ -634,30 +674,11 @@ export class InputHandler extends Disposable implements IInputHandler { continue; } - // insert mode: move characters to right - if (insertMode) { - // right shift cells according to the width - bufferRow.insertCells(this._activeBuffer.x, chWidth - oldWidth, this._activeBuffer.getNullCell(curAttr)); - // test last cell - since the last cell has only room for - // a halfwidth char any fullwidth shifted there is lost - // and will be set to empty cell - if (bufferRow.getWidth(cols - 1) === 2) { - bufferRow.setCellFromCodepoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr); - } - } - - // write current char to buffer and advance cursor - bufferRow.setCellFromCodepoint(this._activeBuffer.x++, code, chWidth, curAttr); - - // fullwidth char - also set next cell to placeholder stub and advance cursor - // for graphemes bigger than fullwidth we can simply loop to zero - // we already made sure above, that this._activeBuffer.x + chWidth will not overflow right - if (chWidth > 0) { - while (--chWidth) { - // other than a regular empty cell a cell following a wide char has no width - bufferRow.setCellFromCodepoint(this._activeBuffer.x++, 0, 0, curAttr); - } - } + data[pos] = code | (chWidth << Content.WIDTH_SHIFT); + if (pendingStart < 0) pendingStart = pos; + pendingCols += chWidth; + // bufferRow.setCellsFromCodepoints(this._activeBuffer.x, chWidth, data, pos, pos+1, curAttr); + this._activeBuffer.x += chWidth; } this._parser.precedingJoinState = precedingJoinState; diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index fd4ed298dc..5a16088bbb 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -49,6 +49,7 @@ export class Buffer extends Disposable implements IBuffer { private _cols: number; private _rows: number; private _isClearing: boolean = false; + constructor( private _hasScrollback: boolean, private _optionsService: IOptionsService, diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index 3bf2220f5a..950b218b88 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -206,6 +206,39 @@ export class LogicalLine implements ILogicalLine { this._data[index * Constants.CELL_INDICIES + Cell.BG] = attrs.bg; } + public setCellsFromCodepoints(index: LogicalColumn, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData): void { + if (index + cols >= this.length) { + this.resizeData(index + cols); + for (let i = this.length; i < index; i++) { + this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; + this._data[i * Constants.CELL_INDICIES + Cell.FG] = 0; + this._data[i * Constants.CELL_INDICIES + Cell.BG] = this.backgroundColor; + } + this.length = index + cols; + } + const data = this._data; + const fg = attrs.fg; + const bg = attrs.bg; + const ext = (attrs.bg & BgFlags.HAS_EXTENDED) ? attrs.extended : undefined; + let j = index * Constants.CELL_INDICIES; + for (let i = start; i < end; i++) { + const contents = codePoints[i]; + let width = (contents >>> Content.WIDTH_SHIFT); + data[j + Cell.CONTENT] = contents; + data[j + Cell.FG] = fg; + data[j + Cell.BG] = bg; + ext && (this._extendedAttrs[index] = ext); + j += 3; index++; + while (--width > 0) { + data[j + Cell.CONTENT] = 0; + data[j + Cell.FG] = fg; + data[j + Cell.BG] = bg; + ext && (this._extendedAttrs[index] = ext); + j += 3; index++; + } + } + } + /** * Cleanup underlying array buffer. * A cleanup will be triggered if the array buffer exceeds the actual used @@ -554,6 +587,10 @@ export class BufferLine implements IBufferLine { this._logicalLine.setCellFromCodepoint(index + this.startColumn, codePoint, width, attrs); } + public setCellsFromCodepoints(index: number, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData): void { + this._cacheValid = false; + this._logicalLine.setCellsFromCodepoints(index + this.startColumn, cols, codePoints, start, end, attrs); + } /** * Add a codepoint to a cell from input handler. diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index c2d176e103..74d8430d50 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -75,7 +75,7 @@ export class BufferService extends Disposable implements IBufferService { if (isWrapped) { lline = oldLine.logical(); } else { - lline = new LogicalLine(0); + lline = new LogicalLine(this.cols); } const newLine = buffer.getBlankLine(eraseAttr, lline) as BufferLine; if (isWrapped && oldLine) { From 7a3fa48258359cf4c2b2f5f6c9af2eb514f05fcc Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Fri, 28 Aug 2026 12:15:32 -0700 Subject: [PATCH 07/15] Allocate sucessive lines in normal buffer from large block. This typically reduces memory usage, allocation, and copying. --- src/common/InputHandler.ts | 9 +- src/common/buffer/Buffer.ts | 22 +++- src/common/buffer/BufferLine.ts | 154 +++++++++++++-------------- src/common/buffer/Types.ts | 4 + src/common/services/BufferService.ts | 17 ++- 5 files changed, 118 insertions(+), 88 deletions(-) diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index 2a4803a1bf..bc8ae2353d 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -15,6 +15,7 @@ import { BufferLine, DEFAULT_ATTR_DATA } from './buffer/BufferLine'; import { IParsingState, IEscapeSequenceParser, IParams, IFunctionIdentifier } from './parser/Types'; import { NULL_CELL_CODE, NULL_CELL_WIDTH, Attributes, FgFlags, BgFlags, Content, UnderlineStyle } from './buffer/Constants'; import { CellData } from './buffer/CellData'; +import { Buffer } from './buffer/Buffer'; import { AttributeData } from './buffer/AttributeData'; import { ICoreService, IBufferService, IOptionsService, ILogService, IMouseStateService, ICharsetService, IUnicodeService, LogLevelEnum, IOscLinkService } from './services/Services'; import { UnicodeService } from './services/UnicodeService'; @@ -526,8 +527,9 @@ export class InputHandler extends Disposable implements IInputHandler { const cols = this._bufferService.cols; const wraparoundMode = this._coreService.decPrivateModes.wraparound; const insertMode = this._coreService.modes.insertMode; + const buffer = this._activeBuffer as Buffer; const curAttr = this._curAttrData; - let bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y) as BufferLine; + let bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y); // Defensive check: bufferRow can be undefined if a resize occurred mid-write due to async // scheduling gaps in WriteBuffer. See https://github.com/xtermjs/xterm.js/issues/5597 @@ -604,7 +606,8 @@ export class InputHandler extends Disposable implements IInputHandler { bufferRow.setCellFromCodepoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr); } } - bufferRow.setCellsFromCodepoints(this._activeBuffer.x - pendingCols, pendingCols, data, pendingStart, pos, curAttr); + const blockSize = buffer.allocateBigBlock(); + bufferRow.setCellsFromCodepoints(this._activeBuffer.x - pendingCols, pendingCols, data, pendingStart, pos, curAttr, blockSize); pendingStart = -1; pendingCols = 0; } @@ -635,7 +638,7 @@ export class InputHandler extends Disposable implements IInputHandler { this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, true); } // row changed, get it again - bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y) as BufferLine + bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y); if (!bufferRow) { return; } diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index 5a16088bbb..820ab474ca 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -104,7 +104,7 @@ export class Buffer extends Disposable implements IBuffer { */ public getBlankLine( attr: IAttributeData, - logicalLine: LogicalLine = new LogicalLine() + logicalLine: LogicalLine = new LogicalLine(this._cols) ): IBufferLine { logicalLine.backgroundColor = attr.bg & ~0xFC000000; return new BufferLine(this._cols, logicalLine); @@ -114,6 +114,21 @@ export class Buffer extends Disposable implements IBuffer { return this._hasScrollback && this.lines.maxLength > this._rows; } + /** + * Should we allocate a big block to be used for multiple lines? + * This makes sense for the regular buffer, which is "mostly-append". + * Furthermore, a logical line can have hightly-variable length, + * so it makes sense to allocate from the end of a large buffer, and + * for sucessive lines, keep alocating from the same buffer as + * long it has room. + * For the alternate buffer, there is a bounded number of lines, + * and a lot more random-access and back-and-forth. + * @returns 0 if the answer is no, otherwise suggested block size + */ + public allocateBigBlock(): number { + return this.hasScrollback ? 24 * this._cols : 0; + } + public get isCursorInViewport(): boolean { const absoluteY = this.ybase + this.y; const relativeY = absoluteY - this.ydisp; @@ -154,8 +169,11 @@ export class Buffer extends Disposable implements IBuffer { if (this.lines.length === 0) { fillAttr ??= DEFAULT_ATTR_DATA; let i = this._rows; + const normalBuffer = this._hasScrollback; while (i--) { - this.lines.push(this.getBlankLine(fillAttr)); + const line = this.getBlankLine(fillAttr, + normalBuffer ? new LogicalLine(0) : undefined); + this.lines.push(line); } } } diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index 950b218b88..59fc5c6716 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -22,12 +22,14 @@ const enum Constants { CLEANUP_THRESHOLD = 2 } -/** Column count within current visible BufferLine(row). +/* + * Column count within current visible BufferLine(row). * The left-most column is column 0. */ export type BufferColumn = number; -/** Column count within current LogicalLine. +/* + * Column count within current LogicalLine. * If the display is 80 columns wide, then LineColumn of the left-most * character of the first wrapped line would normally be 80. * (It might be 79 if the character at column 79 is double-width.) @@ -69,9 +71,12 @@ const EMPTY_DATA = new Uint32Array(0); */ export class LogicalLine implements ILogicalLine { /** + * Available for this line is _data.subarray(_dstaStart, _dataStart + _dataLength) * @internal */ public _data: Uint32Array; + public _dataStart: number = 0; + public _dataLength: number = 0; /** Sparse cache; only read when `IS_COMBINED_MASK` is set in `_data`. */ public _combined: {[index: LogicalColumn]: string} = {}; /** @@ -84,35 +89,43 @@ export class LogicalLine implements ILogicalLine { public backgroundColor: number = 0; /** * Logical "trimmed" length of line. - * Must be no more than this._data.length / 3. + * Must be no more than this._dataLength / 3. */ public length: number = 0; - constructor(cols: number = 0, data = cols === 0 ? EMPTY_DATA : new Uint32Array(cols * Constants.CELL_INDICIES)) { + constructor(cols: number = 0, data: Uint32Array = cols === 0 ? EMPTY_DATA : new Uint32Array(cols * Constants.CELL_INDICIES), start: number = 0, dlength: number = data.length - start) { this._data = data; + this._dataStart = start; + this._dataLength = dlength; } /** * @internal */ - public resizeData(cols: number): void { + public resizeData(cols: number, allocateBigBlock: number = 0): void { const uint32Cells = cols * Constants.CELL_INDICIES; - const oldLength = this._data.length; + const oldLength = this._dataLength; if (uint32Cells >= oldLength) { // increase by at least 50% - const newLength = Math.max(uint32Cells + 60, (3 * oldLength) >> 1); + const newLength = Math.max(uint32Cells + 60, + allocateBigBlock ? allocateBigBlock * 3 : (3 * oldLength) >> 1); const data = new Uint32Array(newLength); - data.set(this._data); + for (let i = 3 * this.length; --i >= 0; ) { + data[i] = this._data[this._dataStart + i]; + } this._data = data; + this._dataStart = 0; + this._dataLength = newLength; } } public getWidth(index: LogicalColumn): number { return index >= this.length ? NULL_CELL_WIDTH - : this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT; + : this._data[this._dataStart + index * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT; } - /** usually same as argument, but adjust if wide or at end. + /** + * Usually same as argument, but adjust if wide or at end. * @internal */ public charStart(column: LogicalColumn): number { @@ -131,7 +144,7 @@ export class LogicalLine implements ILogicalLine { cell.bg = this.backgroundColor; return cell; } - const startIndex = index * Constants.CELL_INDICIES; + const startIndex = this._dataStart + index * Constants.CELL_INDICIES; cell.content = this._data[startIndex + Cell.CONTENT]; cell.fg = this._data[startIndex + Cell.FG]; cell.bg = this._data[startIndex + Cell.BG]; @@ -147,7 +160,7 @@ export class LogicalLine implements ILogicalLine { // prior loadCell into a reused CellData (e.g. $workCell during insert/delete). cell.extended = DEFAULT_ATTR_DATA.extended.clone(); // We use $extended as blueprint and reset the internals - // mimicking the ctor to avoid a new allocation. + // mimicking the ctor to avoid a new allocation. $extended._ext = 0; $extended._urlId = 0; cell.extended = $extended; @@ -157,7 +170,7 @@ export class LogicalLine implements ILogicalLine { /** Returns the string content of the cell. */ public getString(index: number): string { - const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT]; + const content = this._data[this._dataStart + index * Constants.CELL_INDICIES + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { return this._combined[index]; } @@ -170,7 +183,7 @@ export class LogicalLine implements ILogicalLine { /** Get state of protected flag. */ public isProtected(index: number): number { - return this._data[index * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED; + return this._data[this._dataStart + index * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED; } /** @@ -191,10 +204,12 @@ export class LogicalLine implements ILogicalLine { } if (index >= this.length) { this.resizeData(index + 1); + let j = this._dataStart + index * Constants.CELL_INDICIES; for (let i = this.length; i < index; i++) { - this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; - this._data[i * Constants.CELL_INDICIES + Cell.FG] = 0; - this._data[i * Constants.CELL_INDICIES + Cell.BG] = this.backgroundColor; + const j = this._dataStart + i * Constants.CELL_INDICIES; + this._data[j + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; + this._data[j + Cell.FG] = 0; + this._data[j + Cell.BG] = this.backgroundColor; } this.length = index + 1; } @@ -206,13 +221,14 @@ export class LogicalLine implements ILogicalLine { this._data[index * Constants.CELL_INDICIES + Cell.BG] = attrs.bg; } - public setCellsFromCodepoints(index: LogicalColumn, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData): void { + public setCellsFromCodepoints(index: LogicalColumn, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData, allocateBigBlock: number = 0): void { if (index + cols >= this.length) { - this.resizeData(index + cols); + this.resizeData(index + cols, allocateBigBlock); for (let i = this.length; i < index; i++) { - this._data[i * Constants.CELL_INDICIES + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; - this._data[i * Constants.CELL_INDICIES + Cell.FG] = 0; - this._data[i * Constants.CELL_INDICIES + Cell.BG] = this.backgroundColor; + const j = this._dataStart + i * Constants.CELL_INDICIES; + this._data[j + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; + this._data[j + Cell.FG] = 0; + this._data[j + Cell.BG] = this.backgroundColor; } this.length = index + cols; } @@ -220,7 +236,7 @@ export class LogicalLine implements ILogicalLine { const fg = attrs.fg; const bg = attrs.bg; const ext = (attrs.bg & BgFlags.HAS_EXTENDED) ? attrs.extended : undefined; - let j = index * Constants.CELL_INDICIES; + let j = this._dataStart + index * Constants.CELL_INDICIES; for (let i = start; i < end; i++) { const contents = codePoints[i]; let width = (contents >>> Content.WIDTH_SHIFT); @@ -239,39 +255,6 @@ export class LogicalLine implements ILogicalLine { } } - /** - * Cleanup underlying array buffer. - * A cleanup will be triggered if the array buffer exceeds the actual used - * memory by a factor of Constants.CLEANUP_THRESHOLD. - * Returns 0 or 1 indicating whether a cleanup happened. - */ - public cleanupMemory(threshold: number = 1.3): number { - const cols = this.length; - if (cols * Constants.CELL_INDICIES * 4 * threshold < this._data.buffer.byteLength) { - const data = new Uint32Array(Constants.CELL_INDICIES * cols); - data.set(this._data); - this._data = data; - // Remove any cut off combined data - const keys = Object.keys(this._combined); - for (let i = 0; i < keys.length; i++) { - const key = parseInt(keys[i], 10); - if (key >= cols) { - delete this._combined[key]; - } - } - // remove any cut off extended attributes - const extKeys = Object.keys(this._extendedAttrs); - for (let i = 0; i < extKeys.length; i++) { - const key = parseInt(extKeys[i], 10); - if (key >= cols) { - delete this._extendedAttrs[key]; - } - } - return 1; - } - return 0; - } - /** * @internal */ @@ -279,7 +262,8 @@ export class LogicalLine implements ILogicalLine { let index = this.length; while (index > 0) { index--; - const content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT]; + const j = this._dataStart + index * Constants.CELL_INDICIES; + const content = this._data[j + Cell.CONTENT]; if (content & Content.HAS_CONTENT_MASK) { index++; break; @@ -335,7 +319,7 @@ export class LogicalLine implements ILogicalLine { const cellContents: string[] = []; while (startCol < endCol) { const content = startCol >= dataLength ? 0 - : this._data[startCol * Constants.CELL_INDICIES + Cell.CONTENT]; + : this._data[this._dataStart + startCol * Constants.CELL_INDICIES + Cell.CONTENT]; const cp = content & Content.CODEPOINT_MASK; const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR; cellContents.push(chars); @@ -423,10 +407,10 @@ export class BufferLine implements IBufferLine { if (lindex >= this.validEnd) { return [0, '', NULL_CELL_WIDTH, 0]; } - const content = lline._data[index * Constants.CELL_INDICIES + Cell.CONTENT]; + const content = lline._data[lline._dataStart + index * Constants.CELL_INDICIES + Cell.CONTENT]; const cp = content & Content.CODEPOINT_MASK; return [ - lline._data[lindex * Constants.CELL_INDICIES + Cell.FG], + lline._data[lline._dataStart + lindex * Constants.CELL_INDICIES + Cell.FG], (content & Content.IS_COMBINED_MASK) ? lline._combined[lindex] : (cp) ? stringFromCodePoint(cp) : '', @@ -464,7 +448,7 @@ export class BufferLine implements IBufferLine { public getFg(index: number): number { const lline = this._logicalLine; const lcolumn = index + this.startColumn; - return lcolumn >= this.validEnd ? 0 : lline._data[lcolumn * Constants.CELL_INDICIES + Cell.FG]; + return lcolumn >= this.validEnd ? 0 : lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.FG]; } /** Get BG cell component. */ @@ -472,7 +456,7 @@ export class BufferLine implements IBufferLine { index += this.startColumn; const lline = this._logicalLine; return index > lline.length ? lline.backgroundColor - : lline._data[index * Constants.CELL_INDICIES + Cell.BG]; + : lline._data[lline._dataStart + index * Constants.CELL_INDICIES + Cell.BG]; } /** @@ -486,7 +470,7 @@ export class BufferLine implements IBufferLine { return 0; } const lline = this._logicalLine; - return lline._data[index * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK; + return lline._data[lline._dataStart + index * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK; } /** @@ -500,7 +484,7 @@ export class BufferLine implements IBufferLine { if (lcolumn >= this.validEnd) { return 0; } - const content = lline._data[lcolumn * Constants.CELL_INDICIES + Cell.CONTENT]; + const content = lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { const combined = lline._combined[lcolumn]; return combined.charCodeAt(combined.length - 1); @@ -515,7 +499,7 @@ export class BufferLine implements IBufferLine { if (lcolumn >= this.validEnd) { return 0; } - return lline._data[lcolumn * Constants.CELL_INDICIES + Cell.CONTENT] & Content.IS_COMBINED_MASK; + return lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.CONTENT] & Content.IS_COMBINED_MASK; } /** Returns the string content of the cell. */ @@ -525,7 +509,7 @@ export class BufferLine implements IBufferLine { if (lcolumn >= this.validEnd) { return ''; } - const content = lline._data[lcolumn * Constants.CELL_INDICIES + Cell.CONTENT]; + const content = lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { return lline._combined[lcolumn]; } @@ -541,7 +525,7 @@ export class BufferLine implements IBufferLine { const lline = this._logicalLine; const lcolumn = index + this.startColumn; return index >= this.length || lcolumn >= lline.length ? 0 - : lline._data[lcolumn * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED; + : lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.BG] & BgFlags.PROTECTED; } /** @@ -587,9 +571,9 @@ export class BufferLine implements IBufferLine { this._logicalLine.setCellFromCodepoint(index + this.startColumn, codePoint, width, attrs); } - public setCellsFromCodepoints(index: number, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData): void { + public setCellsFromCodepoints(index: number, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData, allocateBigBlock: number = 0): void { this._cacheValid = false; - this._logicalLine.setCellsFromCodepoints(index + this.startColumn, cols, codePoints, start, end, attrs); + this._logicalLine.setCellsFromCodepoints(index + this.startColumn, cols, codePoints, start, end, attrs, allocateBigBlock); } /** @@ -608,7 +592,7 @@ export class BufferLine implements IBufferLine { this.setCellFromCodepoint(index, codePoint, 1, CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE])); return; } - let content = lline._data[lcolumn * Constants.CELL_INDICIES + Cell.CONTENT]; + let content = lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.CONTENT]; if (content & Content.IS_COMBINED_MASK) { // we already have a combined string, simply add lline._combined[lcolumn] += stringFromCodePoint(codePoint); @@ -630,7 +614,7 @@ export class BufferLine implements IBufferLine { content &= ~Content.WIDTH_MASK; content |= width << Content.WIDTH_SHIFT; } - lline._data[lcolumn * Constants.CELL_INDICIES + Cell.CONTENT] = content; + lline._data[lline._dataStart + lcolumn * Constants.CELL_INDICIES + Cell.CONTENT] = content; } public insertCells(pos: number, n: number, fillCellData: ICellData): void { @@ -737,17 +721,20 @@ export class BufferLine implements IBufferLine { throw new Error('invalid call to resize'); } if (cols === this.length) { - return logical._data.length * 4 * Constants.CLEANUP_THRESHOLD < logical._data.buffer.byteLength; + return logical._dataLength * 4 * Constants.CLEANUP_THRESHOLD < logical._data.buffer.byteLength; } const uint32Cells = cols * Constants.CELL_INDICIES; if (cols > this.length) { logical.resizeData(cols); + logical.length = cols; for (let i = this.length; i < cols; ++i) { this.setCell(i, fillCellData); } } else { // optimization: just shrink the view on existing buffer logical._data = logical._data.subarray(0, cols * Constants.CELL_INDICIES); + logical._dataStart = 0; + logical._dataLength = cols * Constants.CELL_INDICIES; // Remove any cut off combined data const keys = Object.keys(logical._combined); for (let i = 0; i < keys.length; i++) { @@ -774,9 +761,10 @@ export class BufferLine implements IBufferLine { * A cleanup will be triggered if the array buffer exceeds the actual used * memory by a factor of Constants.Constants.CLEANUP_THRESHOLD. * Returns 0 or 1 indicating whether a cleanup happened. + * @deprecated */ public cleanupMemory(): number { - return this._logicalLine.cleanupMemory(Constants.CLEANUP_THRESHOLD); + return 0; } /** fill a line with fillCharData */ @@ -814,9 +802,10 @@ export class BufferLine implements IBufferLine { const startColumn = this.startColumn; const data = logicalLine._data; for (let i = this.validEnd; --i >= startColumn; ) { - if ((data[i * Constants.CELL_INDICIES + Cell.CONTENT] & Content.HAS_CONTENT_MASK) - || (noBg && (data[i * Constants.CELL_INDICIES + Cell.BG] & Attributes.CM_MASK))) { - i += data[i * Constants.CELL_INDICIES + Cell.CONTENT] >> Content.WIDTH_SHIFT; + const j = logicalLine._dataStart + i * Constants.CELL_INDICIES; + if ((data[j + Cell.CONTENT] & Content.HAS_CONTENT_MASK) + || (noBg && (data[j + Cell.BG] & Attributes.CM_MASK))) { + i += data[j + Cell.CONTENT] >> Content.WIDTH_SHIFT; return i - startColumn; } } @@ -852,8 +841,11 @@ export class BufferLine implements IBufferLine { public eraseRight(index: BufferColumn): void { this._cacheValid = false; const lineStart = this.startColumn; - const lineEnd = lineStart + index; + let lineEnd = lineStart + index; const lline = this._logicalLine; + if (lineEnd > lineStart && lline.getWidth(lineEnd - 1) === 2) { + lineEnd--; + } if (this.nextBufferLine) { const oldEnd = this.nextBufferLine.startColumn; const count = oldEnd - lineEnd; @@ -881,10 +873,12 @@ export class BufferLine implements IBufferLine { const oldLogical = this._logicalLine; logicalLine.resizeData(column + oldLogical.length); const newData = logicalLine._data; + const dataStart = logicalLine._dataStart; for (let i = logicalLine.length; i < column + oldLogical.length; i++) { - newData[i * Constants.CELL_INDICIES + Cell.CONTENT] = 0; - newData[i * Constants.CELL_INDICIES + Cell.FG] = 0; - newData[i * Constants.CELL_INDICIES + Cell.BG] = logicalLine.backgroundColor; + const i3 = dataStart + i * Constants.CELL_INDICIES; + newData[i3 + Cell.CONTENT] = 0; + newData[i3 + Cell.FG] = 0; + newData[i3 + Cell.BG] = logicalLine.backgroundColor; } logicalLine.copyCellsFrom(oldLogical, 0, column, oldLogical.length, false); /* diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts index c48c26283b..81301de1b2 100644 --- a/src/common/buffer/Types.ts +++ b/src/common/buffer/Types.ts @@ -127,11 +127,15 @@ export interface IBufferLine { loadCell(index: number, cell: ICellData): ICellData; setCell(index: number, cell: ICellData): void; setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void; + setCellsFromCodepoints(index: number, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData): void; addCodepointToCell(index: number, codePoint: number, width: number): void; insertCells(pos: number, n: number, ch: ICellData): void; deleteCells(pos: number, n: number, fill: ICellData): void; replaceCells(start: number, end: number, fill: ICellData, respectProtect?: boolean): void; resize(cols: number, fill: ICellData): boolean; + /** + * @deprecated + */ cleanupMemory(): number; fill(fillCellData: ICellData, respectProtect?: boolean): void; copyFrom(line: IBufferLine): void; diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index 74d8430d50..a2163fcc9e 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -6,6 +6,7 @@ import { Disposable } from '../Lifecycle'; import { IAttributeData, IBuffer, IBufferLine, IBufferSet } from '../buffer/Types'; import { BufferSet } from '../buffer/BufferSet'; +import { Buffer } from '../buffer/Buffer'; import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from './Services'; import { Emitter } from '../Event'; import { BufferLine, LogicalLine } from '../buffer/BufferLine'; @@ -67,13 +68,23 @@ export class BufferService extends Disposable implements IBufferService { * @param isWrapped Whether the new line is wrapped from the previous line. */ public scroll(eraseAttr: IAttributeData, isWrapped: boolean = false): void { - const buffer = this.buffer; + const buffer = this.buffer as Buffer; const topRow = buffer.ybase + buffer.scrollTop; const bottomRow = buffer.ybase + buffer.scrollBottom; + if (bottomRow !== buffer.lines.length - 1) { + buffer.setWrapped(bottomRow + 1, false); + } const oldLine = buffer.lines.get(bottomRow) as BufferLine; - let lline: LogicalLine; + let lline: LogicalLine = oldLine.logical(); + const dbuffer = lline._data; if (isWrapped) { - lline = oldLine.logical(); + } else if (buffer.allocateBigBlock() > 0) { + // In this case we try to use a large block for many lines. + // Grab the rest of the block + const newStart = lline._dataStart + 3 * lline.length; + const newLength = lline._dataLength - 3 * lline.length; + lline._dataLength = lline.length; + lline = new LogicalLine(0, dbuffer, newStart, newLength); } else { lline = new LogicalLine(this.cols); } From fbc57f68bf2f86f8643462c90f0df6e751e3640f Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Sat, 29 Aug 2026 10:29:10 -0700 Subject: [PATCH 08/15] Minor optimization - don't check for url links on each character Also restored CircularList.recycle, pending possible future use - though the initial attempt actually slowed things down. --- src/common/CircularList.ts | 15 +++++++++++++++ src/common/InputHandler.test.ts | 3 ++- src/common/InputHandler.ts | 9 +++++---- src/common/buffer/BufferLine.ts | 11 +++++++++++ src/common/services/BufferService.ts | 5 +++++ 5 files changed, 38 insertions(+), 5 deletions(-) diff --git a/src/common/CircularList.ts b/src/common/CircularList.ts index d47bf2678b..b773391f96 100644 --- a/src/common/CircularList.ts +++ b/src/common/CircularList.ts @@ -31,6 +31,7 @@ export interface ICircularList { get(index: number): T | undefined; set(index: number, value: T): void; push(value: T): void; + recycle(): T; pop(): T | undefined; splice(start: number, deleteCount: number, ...items: T[]): void; trimStart(count: number): void; @@ -135,6 +136,20 @@ export class CircularList extends Disposable implements ICircularList { } } + /** + * Advance ringbuffer index and return current element for recycling. + * Note: The buffer must be full for this method to work. + * @throws When the buffer is not full. + */ + public recycle(): T { + if (this._length !== this._maxLength) { + throw new Error('Can only recycle when the buffer is full'); + } + this._startIndex = ++this._startIndex % this._maxLength; + this.onTrimEmitter.fire(1); + return this._array[this._getCyclicIndex(this._length - 1)]!; + } + /** * Ringbuffer is at max length. */ diff --git a/src/common/InputHandler.test.ts b/src/common/InputHandler.test.ts index 575fb93bb5..8a5ce3994a 100644 --- a/src/common/InputHandler.test.ts +++ b/src/common/InputHandler.test.ts @@ -483,7 +483,8 @@ describe('InputHandler', () => { bufferService.buffer.y = 2; bufferService.buffer.x = 40; inputHandler.eraseInLine(Params.fromArray([2])); - assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false);assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false); + assert.equal(bufferService.buffer.lines.get(2)!.isWrapped, false); + assert.equal(bufferService.buffer.lines.get(3)!.isWrapped, false); }); it('ED2 with scrollOnEraseInDisplay turned on', async () => { const inputHandler = new TestInputHandler( diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index bc8ae2353d..aa41828ae2 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -545,6 +545,7 @@ export class InputHandler extends Disposable implements IInputHandler { } let precedingJoinState = this._parser.precedingJoinState; + const linkId = this._getCurrentLinkId(); let pendingStart = -1; let pendingCols = 0; for (let pos = start; ; ++pos) { @@ -583,10 +584,6 @@ export class InputHandler extends Disposable implements IInputHandler { if (screenReaderMode) { this._onA11yChar.fire(stringFromCodePoint(code)); } - const linkId = this._getCurrentLinkId(); - if (linkId) { - this._oscLinkService.addLineToLink(linkId, this._activeBuffer.ybase + this._activeBuffer.y); - } overflowing = this._activeBuffer.x + chWidth - oldWidth > cols; } else { oldWidth = 0; @@ -595,6 +592,10 @@ export class InputHandler extends Disposable implements IInputHandler { shouldJoin = false; } if (pendingStart >= 0 && (code < 0 || overflowing || shouldJoin)) { + if (linkId) { + this._oscLinkService.addLineToLink(linkId, this._activeBuffer.ybase + this._activeBuffer.y); + } + // insert mode: move characters to right if (insertMode) { // right shift cells according to the width diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index 59fc5c6716..3426226476 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -98,6 +98,11 @@ export class LogicalLine implements ILogicalLine { this._dataStart = start; this._dataLength = dlength; } + public setData(data: Uint32Array, start: number, dlength: number): void { + this._data = data; + this._dataStart = start; + this._dataLength = dlength; + } /** * @internal @@ -392,6 +397,12 @@ export class BufferLine implements IBufferLine { this.length = cols; logicalLine.firstBufferLine ??= this; } + public reinit(cols: number, + logicalLine: LogicalLine): void { + this._logicalLine = logicalLine; + this.length = cols; + logicalLine.firstBufferLine ??= this; + } public get isWrapped(): boolean { return this._logicalLine.firstBufferLine !== this; diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index a2163fcc9e..df7619f42f 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -88,6 +88,11 @@ export class BufferService extends Disposable implements IBufferService { } else { lline = new LogicalLine(this.cols); } + + // A possible optimizaton when willBufferBeTrimmed is to use + // CircularList.recycle instead of creating new BufferLine/LogicalLine + // instances - but it seems to be slightly slower as well as + // more complicated. May be worth investigating why it is slower. const newLine = buffer.getBlankLine(eraseAttr, lline) as BufferLine; if (isWrapped && oldLine) { oldLine.nextBufferLine = newLine; From 3ce563c9cee145ac2c857c393a2dc6c257f50a91 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Sat, 29 Aug 2026 12:00:20 -0700 Subject: [PATCH 09/15] Use recycled lines from CircularList trimming Seems slightly faster to recycle BufferLine but not LogicalLine. --- src/common/buffer/BufferLine.ts | 3 +++ src/common/services/BufferService.ts | 32 +++++++++++++++++----------- 2 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index 3426226476..bd977b9005 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -402,6 +402,9 @@ export class BufferLine implements IBufferLine { this._logicalLine = logicalLine; this.length = cols; logicalLine.firstBufferLine ??= this; + this._cacheValid = false; + this._cache = ''; + this.startColumn = 0; } public get isWrapped(): boolean { diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index df7619f42f..2e9f32d16c 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -71,12 +71,18 @@ export class BufferService extends Disposable implements IBufferService { const buffer = this.buffer as Buffer; const topRow = buffer.ybase + buffer.scrollTop; const bottomRow = buffer.ybase + buffer.scrollBottom; - if (bottomRow !== buffer.lines.length - 1) { + const atBottom = bottomRow === buffer.lines.length - 1; + if (!atBottom) { buffer.setWrapped(bottomRow + 1, false); } const oldLine = buffer.lines.get(bottomRow) as BufferLine; + // Determine whether the buffer is going to be trimmed after insertion. + const willBufferBeTrimmed = buffer.lines.isFull; + let lline: LogicalLine = oldLine.logical(); const dbuffer = lline._data; + const recycledLine = buffer.scrollTop === 0 && atBottom && willBufferBeTrimmed + && buffer.lines.recycle() as BufferLine; if (isWrapped) { } else if (buffer.allocateBigBlock() > 0) { // In this case we try to use a large block for many lines. @@ -84,16 +90,19 @@ export class BufferService extends Disposable implements IBufferService { const newStart = lline._dataStart + 3 * lline.length; const newLength = lline._dataLength - 3 * lline.length; lline._dataLength = lline.length; + // Perhaps should also re-use recycledLine.logical(). + // However, that seems to be slightly slower - unclear why. lline = new LogicalLine(0, dbuffer, newStart, newLength); } else { lline = new LogicalLine(this.cols); } - - // A possible optimizaton when willBufferBeTrimmed is to use - // CircularList.recycle instead of creating new BufferLine/LogicalLine - // instances - but it seems to be slightly slower as well as - // more complicated. May be worth investigating why it is slower. - const newLine = buffer.getBlankLine(eraseAttr, lline) as BufferLine; + let newLine; + if (recycledLine) { + recycledLine.reinit(this.cols, lline); + newLine = recycledLine; + } else { + newLine = buffer.getBlankLine(eraseAttr, lline) as BufferLine; + } if (isWrapped && oldLine) { oldLine.nextBufferLine = newLine; newLine.startColumn = lline.length; @@ -101,12 +110,11 @@ export class BufferService extends Disposable implements IBufferService { lline.backgroundColor = eraseAttr.bg; if (buffer.scrollTop === 0) { - // Determine whether the buffer is going to be trimmed after insertion. - const willBufferBeTrimmed = buffer.lines.isFull; - // Insert the line using the fastest method - if (bottomRow === buffer.lines.length - 1) { - buffer.lines.push(newLine); + if (atBottom) { + if (!willBufferBeTrimmed) { + buffer.lines.push(newLine); + } } else { buffer.lines.splice(bottomRow + 1, 0, newLine); } From 1ccc47e2d5a6ce2896bb99fd9f28129ef0266f44 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Tue, 1 Sep 2026 10:00:35 -0700 Subject: [PATCH 10/15] Use new COLOR_MASK constant when setting LogicalLine's backgroundColor. --- src/common/InputHandler.ts | 2 +- src/common/buffer/Buffer.ts | 4 ++-- src/common/buffer/Constants.ts | 5 +++++ src/common/services/BufferService.ts | 3 ++- 4 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index aa41828ae2..332251a5d7 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -1206,7 +1206,7 @@ export class InputHandler extends Disposable implements IInputHandler { const next = line.nextBufferLine; if (next) next.asUnwrapped(line); line.eraseRight(start); - line.logical().backgroundColor = this._curAttrData.bg & ~0xFC000000; + line.logical().backgroundColor = this._curAttrData.bg & Attributes.COLOR_MASK; } else { line.replaceCells( start, diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index 820ab474ca..c68561eb71 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -11,7 +11,7 @@ import { ExtendedAttrs } from './AttributeData'; import { BufferLine, LogicalLine, DEFAULT_ATTR_DATA } from './BufferLine'; import { reflowLine, reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove } from './BufferReflow'; import { CellData } from './CellData'; -import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH } from './Constants'; +import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH, Attributes } from './Constants'; import { Marker } from './Marker'; import { DEFAULT_CHARSET } from '../data/Charsets'; import { IBufferService, ILogService, IOptionsService } from '../services/Services'; @@ -106,7 +106,7 @@ export class Buffer extends Disposable implements IBuffer { attr: IAttributeData, logicalLine: LogicalLine = new LogicalLine(this._cols) ): IBufferLine { - logicalLine.backgroundColor = attr.bg & ~0xFC000000; + logicalLine.backgroundColor = attr.bg & Attributes.COLOR_MASK; return new BufferLine(this._cols, logicalLine); } diff --git a/src/common/buffer/Constants.ts b/src/common/buffer/Constants.ts index b5a6a4d4fa..69403304ef 100644 --- a/src/common/buffer/Constants.ts +++ b/src/common/buffer/Constants.ts @@ -75,6 +75,11 @@ export const enum Content { } export const enum Attributes { + /** + * Color is encoded using 26 bits. The high-order 2 bits is the + * color mode, which specifies how to interpret the remaining 24 bits. + */ + COLOR_MASK = 0x3FFFFFF, /* CM_MASK | RGB_MASK */ /** * bit 1..8 blue in RGB, color in P256 and P16 */ diff --git a/src/common/services/BufferService.ts b/src/common/services/BufferService.ts index 2e9f32d16c..33e49370dd 100644 --- a/src/common/services/BufferService.ts +++ b/src/common/services/BufferService.ts @@ -7,6 +7,7 @@ import { Disposable } from '../Lifecycle'; import { IAttributeData, IBuffer, IBufferLine, IBufferSet } from '../buffer/Types'; import { BufferSet } from '../buffer/BufferSet'; import { Buffer } from '../buffer/Buffer'; +import { Attributes } from '../buffer/Constants'; import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from './Services'; import { Emitter } from '../Event'; import { BufferLine, LogicalLine } from '../buffer/BufferLine'; @@ -107,7 +108,7 @@ export class BufferService extends Disposable implements IBufferService { oldLine.nextBufferLine = newLine; newLine.startColumn = lline.length; } - lline.backgroundColor = eraseAttr.bg; + lline.backgroundColor = eraseAttr.bg & Attributes.COLOR_MASK; if (buffer.scrollTop === 0) { // Insert the line using the fastest method From a3be9ce6d85eee154f8c05238af5a5a862ae825b Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Tue, 1 Sep 2026 10:06:47 -0700 Subject: [PATCH 11/15] Fix missing addition of LogicalLine._dataStart in setCellFromCodepoint. --- src/common/buffer/BufferLine.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index fb1b589c73..5117fdfee0 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -228,9 +228,10 @@ export class LogicalLine implements ILogicalLine { if (attrs.bg & BgFlags.HAS_EXTENDED) { this._extendedAttrs[index] = attrs.extended; } - this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT); - this._data[index * Constants.CELL_INDICIES + Cell.FG] = attrs.fg; - this._data[index * Constants.CELL_INDICIES + Cell.BG] = attrs.bg; + const j = this._dataStart + index * Constants.CELL_INDICIES; + this._data[j + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT); + this._data[j + Cell.FG] = attrs.fg; + this._data[j + Cell.BG] = attrs.bg; } public setCellsFromCodepoints(index: LogicalColumn, cols: number, codePoints: Uint32Array, start: number, end: number, attrs: IAttributeData, allocateBigBlock: number = 0): void { From b2a36f5f0941cd228924d81cafa80ed4dde7c810 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Tue, 1 Sep 2026 10:31:40 -0700 Subject: [PATCH 12/15] Change getExtended to return undefined when there is no ExtendedAttrs I think this is slightly cleaner and possibly faster, since no cloning needed. --- src/common/buffer/BufferLine.ts | 34 ++++++++++++++++++--------------- src/common/buffer/Types.ts | 2 +- 2 files changed, 20 insertions(+), 16 deletions(-) diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index 5117fdfee0..ef23730014 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -161,23 +161,27 @@ export class LogicalLine implements ILogicalLine { } else { cell.combinedData = ''; } - cell.extended = this.getExtended(index); + if (cell.bg & BgFlags.HAS_EXTENDED) { + cell.extended = this._extendedAttrs[index]!; + } else { + // Do not mutate cell.extended in place: it may still reference this line's map entry from a + // prior loadCell into a reused CellData (e.g. $workCell during insert/dele + // We use $extended as blueprint and reset the internals + // mimicking the ctor to avoid a new allocation. + $extended._ext = 0; + $extended._urlId = 0; + $extended.payload = undefined; + cell.extended = $extended; + } + return cell; } - public getExtended(index: LogicalColumn, validEnd: LogicalColumn = this.length): IExtendedAttrs { - const startIndex = this._dataStart + index * Constants.CELL_INDICIES; - if (this._data[startIndex + Cell.BG] & BgFlags.HAS_EXTENDED) { - return this._extendedAttrs[index]!; - } - // Do not mutate cell.extended in place: it may still reference this line's map entry from a - // prior loadCell into a reused CellData (e.g. $workCell during insert/delete). - // We use $extended as blueprint and reset the internals - // mimicking the ctor to avoid a new allocation. - $extended._ext = 0; - $extended._urlId = 0; - $extended.payload = undefined; - return $extended; + public getExtended(index: LogicalColumn, validEnd: LogicalColumn = this.length): IExtendedAttrs | undefined { + return index < this.length + && (this._data[this._dataStart + index * Constants.CELL_INDICIES + Cell.BG] & BgFlags.HAS_EXTENDED) + ? this._extendedAttrs[index] + : undefined; } /** Returns the string content of the cell. */ @@ -571,7 +575,7 @@ export class BufferLine implements IBufferLine { return lline.loadCell(lcolumn, cell); } - public getExtended(index: number): IExtendedAttrs { + public getExtended(index: number): IExtendedAttrs | undefined { const lline = this._logicalLine; const lcolumn = index + this.startColumn; return lline.getExtended(lcolumn, this.validEnd); diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts index 36873a96e0..70fac1c1ce 100644 --- a/src/common/buffer/Types.ts +++ b/src/common/buffer/Types.ts @@ -153,7 +153,7 @@ export interface IBufferLine { getCodePoint(index: number): number; isCombined(index: number): number; getString(index: number): string; - getExtended(index: number): IExtendedAttrs; + getExtended(index: number): IExtendedAttrs | undefined; } export interface IMarker extends IDisposable { From e53f2d30bd0f1b8f723e9b61843517cdb6e792de Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Tue, 1 Sep 2026 11:15:37 -0700 Subject: [PATCH 13/15] Fix issue in setCellFromCodepoint reported by lint --- src/common/buffer/BufferLine.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index ef23730014..b5da06dd3f 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -220,12 +220,12 @@ export class LogicalLine implements ILogicalLine { } if (index >= this.length) { this.resizeData(index + 1); - let j = this._dataStart + index * Constants.CELL_INDICIES; + let j = this._dataStart + this.length * Constants.CELL_INDICIES; for (let i = this.length; i < index; i++) { - const j = this._dataStart + i * Constants.CELL_INDICIES; this._data[j + Cell.CONTENT] = NULL_CELL_WIDTH << Content.WIDTH_SHIFT; this._data[j + Cell.FG] = 0; this._data[j + Cell.BG] = this.backgroundColor; + j += Constants.CELL_INDICIES; } this.length = index + 1; } From 6ce5d6b5bf5abdfe43ecaf6b7aa6ada0e19306c8 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Tue, 1 Sep 2026 12:38:30 -0700 Subject: [PATCH 14/15] Fixes to integration tests. --- addons/addon-image/test/ImageAddon.test.ts | 4 ++-- .../test/SerializeAddon.test.ts | 22 ++++++++++++------- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/addons/addon-image/test/ImageAddon.test.ts b/addons/addon-image/test/ImageAddon.test.ts index f4e54d7f2e..5153b3ab22 100644 --- a/addons/addon-image/test/ImageAddon.test.ts +++ b/addons/addon-image/test/ImageAddon.test.ts @@ -117,8 +117,8 @@ test.describe('ImageAddon', () => { ); } // bufferline privates - strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._data instanceof Uint32Array'), true); - strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._extendedAttrs instanceof Object'), true); + strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._logicalLine._data instanceof Uint32Array'), true); + strictEqual(await ctx.page.evaluate('window.term._core.buffer.lines.get(0)._logicalLine._extendedAttrs instanceof Object'), true); // inputhandler privates strictEqual(await ctx.page.evaluate('window.term._core._inputHandler._curAttrData.constructor.name'), '_AttributeData'); strictEqual(await ctx.page.evaluate('window.term._core._inputHandler._parser.constructor.name'), 'EscapeSequenceParser'); diff --git a/addons/addon-serialize/test/SerializeAddon.test.ts b/addons/addon-serialize/test/SerializeAddon.test.ts index c8dba3039b..ce84b4fcd7 100644 --- a/addons/addon-serialize/test/SerializeAddon.test.ts +++ b/addons/addon-serialize/test/SerializeAddon.test.ts @@ -49,14 +49,20 @@ test.describe('SerializeAddon', () => { for (let i = 0; i < buffer.length; i++) { // Do this intentionally to get content of underlining source const bufferLine = buffer.getLine(i)._line; - lines.push(JSON.stringify(bufferLine, (key, value) => { - // BufferLine caches are internal/transient and can legitimately differ - // across equivalent terminal states. - if (key === '_stringCache' || key === '_stringCacheEntryRef') { - return undefined; - } - return value; - })); + if (bufferLine.isWrapped) { + lines.push({ startColumn: bufferLine.startColumn, length: bufferLine.length}); + } else { + const logical = bufferLine.logical(); + lines.push(JSON.stringify(logical, (key, value) => { + if (key === 'firstBufferLine' ) { + return undefined; + } + if (key === '_data') { + return new Uint32Array(value.buffer, 0, logical.length * 3); + } + return value; + })); + } } return { x: buffer.cursorX, From 95b05e8a588445c141eff37d4dae488015a24d63 Mon Sep 17 00:00:00 2001 From: Per Bothner Date: Fri, 25 Sep 2026 09:45:50 -0700 Subject: [PATCH 15/15] Move BufferColumn and LogicalColumn to Types.ts. --- src/common/buffer/BufferLine.ts | 16 +--------------- src/common/buffer/Types.ts | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index b5da06dd3f..ece7f53a5f 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -3,7 +3,7 @@ * @license MIT */ -import { CharData, IAttributeData, IBufferLine, ILogicalLine, ICellData, IExtendedAttrs } from './Types'; +import { CharData, IAttributeData, IBufferLine, ILogicalLine, ICellData, IExtendedAttrs, BufferColumn, LogicalColumn } from './Types'; import { AttributeData } from './AttributeData'; import { CellData } from './CellData'; import { Attributes, BgFlags, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from './Constants'; @@ -22,20 +22,6 @@ const enum Constants { CLEANUP_THRESHOLD = 2 } -/* - * Column count within current visible BufferLine(row). - * The left-most column is column 0. - */ -export type BufferColumn = number; - -/* - * Column count within current LogicalLine. - * If the display is 80 columns wide, then LineColumn of the left-most - * character of the first wrapped line would normally be 80. - * (It might be 79 if the character at column 79 is double-width.) - */ -export type LogicalColumn = number; - /** * Cell member indices. * diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts index 70fac1c1ce..b27541d222 100644 --- a/src/common/buffer/Types.ts +++ b/src/common/buffer/Types.ts @@ -14,6 +14,20 @@ export type BufferIndex = [number, number]; export type CharData = [attr: number, char: string, width: number, code: number]; +/* + * Column count within current visible BufferLine(row). + * The left-most column is column 0. + */ +export type BufferColumn = number; + +/* + * Column count within current LogicalLine. + * If the display is 80 columns wide, then LineColumn of the left-most + * character of the first wrapped line would normally be 80. + * (It might be 79 if the character at column 79 is double-width.) + */ +export type LogicalColumn = number; + export interface IExtendedAttrs { ext: number; underlineStyle: UnderlineStyle;