Parser hooks

src/InputHandler.test.ts

@@ -53,54 +53,52 @@ describe('InputHandler', () => {
     it('should call Terminal.setOption with correct params', () => {
       const optionsService = new MockOptionsService();
       const inputHandler = new InputHandler(new MockInputHandlingTerminal(), new MockBufferService(80, 30), new MockCoreService(), new MockDirtyRowService(), new MockLogService(), optionsService);
-      const collect = ' ';
 
-      inputHandler.setCursorStyle(Params.fromArray([0]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([0]));
       assert.equal(optionsService.options['cursorStyle'], 'block');
       assert.equal(optionsService.options['cursorBlink'], true);
 
       optionsService.options = clone(DEFAULT_OPTIONS);
-      inputHandler.setCursorStyle(Params.fromArray([1]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([1]));
       assert.equal(optionsService.options['cursorStyle'], 'block');
       assert.equal(optionsService.options['cursorBlink'], true);
 
       optionsService.options = clone(DEFAULT_OPTIONS);
-      inputHandler.setCursorStyle(Params.fromArray([2]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([2]));
       assert.equal(optionsService.options['cursorStyle'], 'block');
       assert.equal(optionsService.options['cursorBlink'], false);
 
       optionsService.options = clone(DEFAULT_OPTIONS);
-      inputHandler.setCursorStyle(Params.fromArray([3]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([3]));
       assert.equal(optionsService.options['cursorStyle'], 'underline');
       assert.equal(optionsService.options['cursorBlink'], true);
 
       optionsService.options = clone(DEFAULT_OPTIONS);
-      inputHandler.setCursorStyle(Params.fromArray([4]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([4]));
       assert.equal(optionsService.options['cursorStyle'], 'underline');
       assert.equal(optionsService.options['cursorBlink'], false);
 
       optionsService.options = clone(DEFAULT_OPTIONS);
-      inputHandler.setCursorStyle(Params.fromArray([5]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([5]));
       assert.equal(optionsService.options['cursorStyle'], 'bar');
       assert.equal(optionsService.options['cursorBlink'], true);
 
       optionsService.options = clone(DEFAULT_OPTIONS);
-      inputHandler.setCursorStyle(Params.fromArray([6]), collect);
+      inputHandler.setCursorStyle(Params.fromArray([6]));
       assert.equal(optionsService.options['cursorStyle'], 'bar');
       assert.equal(optionsService.options['cursorBlink'], false);
     });
   });
   describe('setMode', () => {
     it('should toggle Terminal.bracketedPasteMode', () => {
       const terminal = new MockInputHandlingTerminal();
-      const collect = '?';
       terminal.bracketedPasteMode = false;
       const inputHandler = new InputHandler(terminal, new MockBufferService(80, 30), new MockCoreService(), new MockDirtyRowService(), new MockLogService(), new MockOptionsService());
       // Set bracketed paste mode
-      inputHandler.setMode(Params.fromArray([2004]), collect);
+      inputHandler.setModePrivate(Params.fromArray([2004]));
       assert.equal(terminal.bracketedPasteMode, true);
       // Reset bracketed paste mode
-      inputHandler.resetMode(Params.fromArray([2004]), collect);
+      inputHandler.resetModePrivate(Params.fromArray([2004]));
       assert.equal(terminal.bracketedPasteMode, false);
     });
   });

src/Terminal.ts

@@ -55,7 +55,7 @@ import { Disposable } from 'common/Lifecycle';
 import { IBufferSet, IBuffer } from 'common/buffer/Types';
 import { Attributes } from 'common/buffer/Constants';
 import { MouseService } from 'browser/services/MouseService';
-import { IParams } from 'common/parser/Types';
+import { IParams, IFunctionIdentifier } from 'common/parser/Types';
 import { CoreService } from 'common/services/CoreService';
 import { LogService } from 'common/services/LogService';
 import { ILinkifier, IMouseZoneManager, LinkMatcherHandler, ILinkMatcherOptions, IViewport } from 'browser/Types';
@@ -1397,9 +1397,19 @@ export class Terminal extends Disposable implements ITerminal, IDisposable, IInp
     this._customKeyEventHandler = customKeyEventHandler;
   }
 
+  /** Add handler for ESC escape sequence. See xterm.d.ts for details. */
+  public addEscHandler(id: IFunctionIdentifier, callback: () => boolean): IDisposable {
+    return this._inputHandler.addEscHandler(id, callback);
+  }
+
+  /** Add handler for DCS escape sequence. See xterm.d.ts for details. */
+  public addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
+    return this._inputHandler.addDcsHandler(id, callback);
+  }
+
   /** Add handler for CSI escape sequence. See xterm.d.ts for details. */
-  public addCsiHandler(flag: string, callback: (params: IParams, collect: string) => boolean): IDisposable {
-    return this._inputHandler.addCsiHandler(flag, callback);
+  public addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
+    return this._inputHandler.addCsiHandler(id, callback);
   }
   /** Add handler for OSC escape sequence. See xterm.d.ts for details. */
   public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {

src/TestUtils.test.ts

@@ -15,7 +15,7 @@ import { AttributeData } from 'common/buffer/AttributeData';
 import { IColorManager, IColorSet, ILinkMatcherOptions, ILinkifier, IViewport } from 'browser/Types';
 import { IOptionsService } from 'common/services/Services';
 import { EventEmitter } from 'common/EventEmitter';
-import { IParams } from 'common/parser/Types';
+import { IParams, IFunctionIdentifier } from 'common/parser/Types';
 import { ISelectionService } from 'browser/services/Services';
 
 export class TestTerminal extends Terminal {
@@ -74,11 +74,17 @@ export class MockTerminal implements ITerminal {
   attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
     throw new Error('Method not implemented.');
   }
-  addCsiHandler(flag: string, callback: (params: IParams, collect: string) => boolean): IDisposable {
-      throw new Error('Method not implemented.');
+  addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  addEscHandler(id: IFunctionIdentifier, handler: () => boolean): IDisposable {
+    throw new Error('Method not implemented.');
   }
   addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
-      throw new Error('Method not implemented.');
+    throw new Error('Method not implemented.');
   }
   registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => boolean | void, options?: ILinkMatcherOptions): number {
     throw new Error('Method not implemented.');

src/Types.d.ts

@@ -9,7 +9,7 @@ import { IEvent, IEventEmitter } from 'common/EventEmitter';
 import { IColorSet, ILinkifier, ILinkMatcherOptions, IViewport } from 'browser/Types';
 import { IOptionsService } from 'common/services/Services';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IParams } from 'common/parser/Types';
+import { IParams, IFunctionIdentifier } from 'common/parser/Types';
 
 export type CustomKeyEventHandler = (event: KeyboardEvent) => boolean;
 
@@ -113,7 +113,8 @@ export interface IInputHandler {
   /** CSI ` */ charPosAbsolute(params: IParams): void;
   /** CSI a */ hPositionRelative(params: IParams): void;
   /** CSI b */ repeatPrecedingCharacter(params: IParams): void;
-  /** CSI c */ sendDeviceAttributes(params: IParams, collect?: string): void;
+  /** CSI c */ sendDeviceAttributesPrimary(params: IParams): void;
+               sendDeviceAttributesSecondary(params: IParams): void;
   /** CSI d */ linePosAbsolute(params: IParams): void;
   /** CSI e */ vPositionRelative(params: IParams): void;
   /** CSI f */ hVPosition(params: IParams): void;
@@ -200,7 +201,9 @@ export interface IPublicTerminal extends IDisposable {
   writeln(data: string): void;
   open(parent: HTMLElement): void;
   attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void;
-  addCsiHandler(flag: string, callback: (params: IParams, collect: string) => boolean): IDisposable;
+  addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable;
+  addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable;
+  addEscHandler(id: IFunctionIdentifier, callback: () => boolean): IDisposable;
   addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable;
   registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => void, options?: ILinkMatcherOptions): number;
   deregisterLinkMatcher(matcherId: number): void;

src/common/parser/Constants.ts

@@ -43,3 +43,16 @@ export const enum ParserAction {
   DCS_PUT = 13,
   DCS_UNHOOK = 14
 }
+
+/**
+ * Internal states of OscParser.
+ */
+export const enum OscState {
+  START = 0,
+  ID = 1,
+  PAYLOAD = 2,
+  ABORT = 3
+}
+
+// payload limit for OSC and DCS
+export const PAYLOAD_LIMIT = 10000000;