Support delayed stack trace loading

This capability of the Debug Adapter Protocol supports
the delayed loading of parts of the stack. It requires
that both the 'startFrame' and 'levels' arguments and
the 'totalFrames' result of the 'StackTrace' requests
are supported. It helps to avoid duplicated top stack
frame and limited number of frames in the CALLSTACK
pane (how many can be transmitted in one message).

IoT.js-VSCode-DCO-1.0-Signed-off-by: Daniella Barsony [email protected]
IoT.js-VSCode-DCO-1.0-Signed-off-by: Robert Sipka [email protected]

Author: robertsipka

src/IotjsDebugger.ts

@@ -28,7 +28,7 @@ import { IAttachRequestArguments, SourceSendingOptions, TemporaryBreakpoint } fr
 import { JerryDebuggerClient, JerryDebuggerOptions } from './JerryDebuggerClient';
 import {
   JerryDebugProtocolDelegate, JerryDebugProtocolHandler, JerryMessageScriptParsed, JerryEvalResult,
-  JerryMessageExceptionHit, JerryMessageBreakpointHit
+  JerryMessageExceptionHit, JerryMessageBreakpointHit, JerryBacktraceResult
 } from './JerryProtocolHandler';
 import { EVAL_RESULT_SUBTYPE, CLIENT as CLIENT_PACKAGE } from './JerryProtocolConstants';
 import { Breakpoint } from './JerryBreakpoints';
@@ -76,7 +76,7 @@ class IotjsDebugSession extends DebugSession {
     response.body.supportsEvaluateForHovers = false;
     response.body.supportsStepBack = false;
     response.body.supportsRestartRequest = false;
-    response.body.supportsDelayedStackTraceLoading = false;
+    response.body.supportsDelayedStackTraceLoading = true;
 
     this._sourceSendingOptions = <SourceSendingOptions>{
       contextReset: false,
@@ -353,18 +353,19 @@ class IotjsDebugSession extends DebugSession {
     response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments
   ): Promise<void> {
     try {
-      const backtrace = await this._protocolhandler.requestBacktrace();
-      const stk = backtrace.map((f, i) => new StackFrame(
-          1000 + i,
-          f.func.name || 'global',
-          this.pathToSource(`${this._args.localRoot}/${this.pathToBasename(f.func.sourceName)}`),
-          f.line,
-          f.func.column
-        )
+      const backtraceData: JerryBacktraceResult = await this._protocolhandler.requestBacktrace(args.startFrame,
+                                                                                               args.levels);
+      const stk = backtraceData.backtrace.map((f, i) => new StackFrame(
+        1000 + i,
+        f.func.name || 'global',
+        this.pathToSource(`${this._args.localRoot}/${this.pathToBasename(f.func.sourceName)}`),
+        f.line,
+        f.func.column)
       );
 
       response.body = {
         stackFrames: stk,
+        totalFrames: backtraceData.totalFrames
       };
 
       this.sendResponse(response);

src/JerryProtocolConstants.ts

@@ -17,7 +17,7 @@
 'use strict';
 
 // Expected JerryScript debugger protocol version.
-export const JERRY_DEBUGGER_VERSION = 3;
+export const JERRY_DEBUGGER_VERSION = 5;
 
 // Packages sent from the server to the client.
 export enum SERVER {
@@ -40,13 +40,14 @@ export enum SERVER {
   JERRY_DEBUGGER_EXCEPTION_HIT = 17,
   JERRY_DEBUGGER_EXCEPTION_STR = 18,
   JERRY_DEBUGGER_EXCEPTION_STR_END = 19,
-  JERRY_DEBUGGER_BACKTRACE = 20,
-  JERRY_DEBUGGER_BACKTRACE_END = 21,
-  JERRY_DEBUGGER_EVAL_RESULT = 22,
-  JERRY_DEBUGGER_EVAL_RESULT_END = 23,
-  JERRY_DEBUGGER_WAIT_FOR_SOURCE = 24,
-  JERRY_DEBUGGER_OUTPUT_RESULT = 25,
-  JERRY_DEBUGGER_OUTPUT_RESULT_END = 26
+  JERRY_DEBUGGER_BACKTRACE_TOTAL = 20,
+  JERRY_DEBUGGER_BACKTRACE = 21,
+  JERRY_DEBUGGER_BACKTRACE_END = 22,
+  JERRY_DEBUGGER_EVAL_RESULT = 23,
+  JERRY_DEBUGGER_EVAL_RESULT_END = 24,
+  JERRY_DEBUGGER_WAIT_FOR_SOURCE = 25,
+  JERRY_DEBUGGER_OUTPUT_RESULT = 26,
+  JERRY_DEBUGGER_OUTPUT_RESULT_END = 27
 }
 
 // Subtypes of eval.

src/JerryProtocolHandler.ts

@@ -44,7 +44,7 @@ export interface ParserStackFrame {
 }
 
 export interface JerryDebugProtocolDelegate {
-  onBacktrace?(backtrace: Array<Breakpoint>): void;
+  onBacktrace?(backtrace: JerryBacktraceResult): void;
   onBreakpointHit?(message: JerryMessageBreakpointHit, stopType: string): void;
   onExceptionHit?(message: JerryMessageExceptionHit): void;
   onEvalResult?(subType: number, result: string): void;
@@ -85,6 +85,11 @@ interface ProtocolFunctionMap {
   [type: number]: (data: Uint8Array) => void;
 }
 
+export interface JerryBacktraceResult {
+  totalFrames: number;
+  backtrace: Array<Breakpoint>;
+}
+
 interface FunctionMap {
   [cp: string]: ParsedFunction;
 }
@@ -143,7 +148,7 @@ export class JerryDebugProtocolHandler {
   private evalResultData?: Uint8Array;
   private functions: FunctionMap = {};
   private newFunctions: FunctionMap = {};
-  private backtrace: Array<Breakpoint> = [];
+  private backtraceData: JerryBacktraceResult = {totalFrames : 0, backtrace: []};
 
   private nextScriptID: number = 1;
   private exceptionData?: Uint8Array;
@@ -187,6 +192,7 @@ export class JerryDebugProtocolHandler {
       [SP.SERVER.JERRY_DEBUGGER_EXCEPTION_HIT]: this.onBreakpointHit,
       [SP.SERVER.JERRY_DEBUGGER_EXCEPTION_STR]: this.onExceptionStr,
       [SP.SERVER.JERRY_DEBUGGER_EXCEPTION_STR_END]: this.onExceptionStr,
+      [SP.SERVER.JERRY_DEBUGGER_BACKTRACE_TOTAL]: this.onBacktrace,
       [SP.SERVER.JERRY_DEBUGGER_BACKTRACE]: this.onBacktrace,
       [SP.SERVER.JERRY_DEBUGGER_BACKTRACE_END]: this.onBacktrace,
       [SP.SERVER.JERRY_DEBUGGER_EVAL_RESULT]: this.onEvalResult,
@@ -547,25 +553,26 @@ export class JerryDebugProtocolHandler {
     this.lastStopType = null;
   }
 
-  public onBacktrace(data: Uint8Array): Breakpoint[] {
+  public onBacktrace(data: Uint8Array): JerryBacktraceResult {
     this.logPacket('Backtrace');
-    for (let i = 1; i < data.byteLength; i += this.byteConfig.cpointerSize + 4) {
-      const breakpointData = this.decodeMessage('CI', data, i);
-      this.backtrace.push(this.getBreakpoint(breakpointData).breakpoint);
+
+    if (data[0] === SP.SERVER.JERRY_DEBUGGER_BACKTRACE_TOTAL) {
+      this.backtraceData.totalFrames = this.decodeMessage('I', data, 1);
+      this.backtraceData.backtrace = [];
+    } else {
+      for (let i = 1; i < data.byteLength; i += this.byteConfig.cpointerSize + 4) {
+        const breakpointData = this.decodeMessage('CI', data, i);
+        this.backtraceData.backtrace.push(this.getBreakpoint(breakpointData).breakpoint);
+      }
     }
 
     if (data[0] === SP.SERVER.JERRY_DEBUGGER_BACKTRACE_END) {
       if (this.delegate.onBacktrace) {
-        this.delegate.onBacktrace(this.backtrace);
+        this.delegate.onBacktrace(this.backtraceData);
       }
-
-      const bt = this.backtrace;
-      this.backtrace = [];
-
-      return bt;
     }
 
-    return [];
+    return this.backtraceData;
   }
 
   public onEvalResult(data: Uint8Array): JerryEvalResult {
@@ -741,11 +748,21 @@ export class JerryDebugProtocolHandler {
     ]));
   }
 
-  public requestBacktrace(): Promise<any> {
+  public requestBacktrace(start?: number, levels?: number): Promise<any> {
+    if (start === undefined)
+      start = 0;
+    if (levels === undefined)
+      levels = 0;
+
     if (!this.lastBreakpointHit) {
       return Promise.reject(new Error('backtrace not allowed while app running'));
     }
-    return this.sendRequest(encodeMessage(this.byteConfig, 'BI', [SP.CLIENT.JERRY_DEBUGGER_GET_BACKTRACE, 0]));
+
+    return this.sendRequest(encodeMessage(this.byteConfig, 'BIIB',
+                                          [SP.CLIENT.JERRY_DEBUGGER_GET_BACKTRACE,
+                                           start,
+                                           start + levels,
+                                           1]));
   }
 
   logPacket(description: string, ignorable: boolean = false) {

src/test/JerryProtocolHandler.test.ts

@@ -342,7 +342,7 @@ suite('JerryProtocolHandler', () => {
 
         test('aborts when unhandled message sent', () => {
             delegate.onError.resetHistory();
-            const array = Uint8Array.from([SP.SERVER.JERRY_DEBUGGER_CONFIGURATION, 200, 4, 1, 3]);
+            const array = Uint8Array.from([SP.SERVER.JERRY_DEBUGGER_CONFIGURATION, 200, 4, 1, 5]);
             handler.onMessage(array);
             assert(delegate.onError.notCalled);
             array[0] = 255;