@ton/sandbox 0.21.0-debugger.1 → 0.21.0-debugger.3

package/dist/debugger/Debuggee.js

@@ -3,10 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TVMDebugSession = exports.Debuggee = void 0;
+exports.Debuggee = void 0;
 const node_events_1 = __importDefault(require("node:events"));
-const debugadapter_1 = require("@vscode/debugadapter");
-const node_path_1 = require("node:path");
 class Debuggee extends node_events_1.default {
     constructor(executor, finishedCallback) {
         super();
@@ -18,6 +16,7 @@ class Debuggee extends node_events_1.default {
         this.breakpoints = new Map();
         this.breakpointID = 0;
         this.frames = [];
+        this.globals = [];
         this.executor = executor;
         this.executor.debugLogFunc = (s) => { this.sendEvent('output', s); };
         this.finishedCallback = finishedCallback;
@@ -33,6 +32,10 @@ class Debuggee extends node_events_1.default {
             }
         }
     }
+    setDebugInfo(debugInfo) {
+        this.setSourceMap(debugInfo.sourceMap);
+        this.setGlobals(debugInfo.globals);
+    }
     setSourceMap(sourceMap) {
         this.sourceMap = sourceMap;
         for (const di in sourceMap) {
@@ -43,6 +46,9 @@ class Debuggee extends node_events_1.default {
             this.availableLines[sem.path].push(sem.line);
         }
     }
+    setGlobals(globals) {
+        this.globals = globals;
+    }
     getAvailableSourcePaths() {
         return Object.keys(this.availableLines);
     }
@@ -57,10 +63,16 @@ class Debuggee extends node_events_1.default {
         return lines.indexOf(line) >= 0;
     }
     continue() {
-        this.stepUntilLine(true);
+        this.stepUntil({ type: 'breakpoint' });
+    }
+    stepIn() {
+        this.stepUntil({ type: 'any-line', stopEvent: 'stopOnStep' });
     }
-    step(stopEvent = 'stopOnStep') {
-        this.stepUntilLine(false, stopEvent);
+    stepOver() {
+        this.stepUntil({ type: 'next-line' });
+    }
+    stepOut() {
+        this.stepUntil({ type: 'out' });
     }
     startGetMethod(args) {
         this.ptr = this.executor.sbsGetMethodSetup(args);
@@ -74,6 +86,14 @@ class Debuggee extends node_events_1.default {
         this.ptr = emptr;
         this.debugType = 'tx';
     }
+    getC7() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodC7(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionC7(this.ptr);
+        }
+    }
     vmStep() {
         switch (this.debugType) {
             case 'get':
@@ -98,6 +118,59 @@ class Debuggee extends node_events_1.default {
                 return this.executor.sbsTransactionStack(this.ptr);
         }
     }
+    getContParam() {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodGetContParam(this.ptr);
+            case 'tx':
+                return this.executor.sbsTransactionGetContParam(this.ptr);
+        }
+    }
+    setContParam(param) {
+        switch (this.debugType) {
+            case 'get':
+                return this.executor.sbsGetMethodSetContParam(this.ptr, param);
+            case 'tx':
+                return this.executor.sbsTransactionSetContParam(this.ptr, param);
+        }
+    }
+    getLocalVariables() {
+        const sme = this.currentSourceMapEntry();
+        if (sme === undefined || sme.type !== 'statement') {
+            return undefined;
+        }
+        const vars = [];
+        const stack = this.getStack();
+        for (let i = 0; i < sme.variables.length; i++) {
+            vars.push({
+                name: sme.variables[i],
+                value: stack[i],
+            });
+        }
+        return vars;
+    }
+    getGlobalVariables() {
+        const vars = [];
+        const c7item = this.getC7();
+        if (c7item.type !== 'tuple') {
+            return undefined;
+        }
+        const c7 = c7item.items;
+        for (let i = 0; i < this.globals.length; i++) {
+            if (i + 1 < c7.length) {
+                vars.push({
+                    name: this.globals[i].name,
+                    value: c7[i + 1],
+                });
+                continue;
+            }
+            vars.push({
+                name: this.globals[i].name,
+                value: { type: 'null' },
+            });
+        }
+        return vars;
+    }
     currentDebugInfoNumber() {
         const codepos = this.codePos();
         const cell = this.codeCells.get(codepos.hash);
@@ -180,7 +253,20 @@ class Debuggee extends node_events_1.default {
         }
         this.finishedCallback(r);
     }
-    stepUntilLine(breakpointsOnly, stopEvent) {
+    stackFrames() {
+        return this.frames;
+    }
+    stepUntil(what) {
+        let until;
+        switch (what.type) {
+            case 'next-line':
+            case 'out': {
+                until = { type: what.type, depth: this.frames.length };
+                break;
+            }
+            default:
+                until = what;
+        }
         while (true) {
             const finished = this.vmStep();
             if (finished) {
@@ -188,31 +274,73 @@ class Debuggee extends node_events_1.default {
                 return;
             }
             const sme = this.currentSourceMapEntry();
-            if (sme !== undefined && (!breakpointsOnly || this.hasBreakpoint(sme.path, sme.line))) {
-                if (breakpointsOnly) {
-                    this.sendEvent('stopOnBreakpoint');
+            if (sme !== undefined) {
+                switch (sme.type) {
+                    case 'statement': {
+                        if (sme.firstStatement) {
+                            this.frames.push({
+                                function: sme.function,
+                                path: sme.path,
+                                line: sme.line,
+                            });
+                            this.setContParam(this.frames.length);
+                        }
+                        this.frames[this.frames.length - 1].line = sme.line;
+                        switch (until.type) {
+                            case 'breakpoint': {
+                                if (this.hasBreakpoint(sme.path, sme.line)) {
+                                    this.sendEvent('stopOnBreakpoint');
+                                    return;
+                                }
+                                break;
+                            }
+                            case 'any-line': {
+                                this.sendEvent(until.stopEvent);
+                                return;
+                            }
+                            case 'next-line': {
+                                if (this.frames.length <= until.depth) {
+                                    this.sendEvent('stopOnStep');
+                                    return;
+                                }
+                                break;
+                            }
+                            case 'out': {
+                                if (this.frames.length < until.depth) {
+                                    this.sendEvent('stopOnStep');
+                                    return;
+                                }
+                                break;
+                            }
+                        }
+                        break;
+                    }
+                    case 'return': {
+                        this.frames.pop();
+                        break;
+                    }
+                    case 'catch': {
+                        this.frames = this.frames.slice(0, this.getContParam());
+                        break;
+                    }
                 }
-                else if (stopEvent !== undefined) {
-                    this.sendEvent(stopEvent);
-                }
-                return;
             }
         }
     }
-    prepareGetMethod(args, sourceMap) {
+    prepareGetMethod(args, debugInfo) {
         this.startGetMethod(args);
         this.setCodeCells(args.code);
-        this.setSourceMap(sourceMap);
+        this.setDebugInfo(debugInfo);
     }
-    prepareTransaction(args, code, sourceMap) {
+    prepareTransaction(args, code, debugInfo) {
         this.startTransaction(args);
         this.setCodeCells(code);
-        this.setSourceMap(sourceMap);
+        this.setDebugInfo(debugInfo);
     }
     start(debug, stopOnEntry) {
         if (debug) {
             if (stopOnEntry) {
-                this.step('stopOnEntry');
+                this.stepUntil({ type: 'any-line', stopEvent: 'stopOnBreakpoint' });
             }
             else {
                 this.continue();
@@ -224,244 +352,3 @@ class Debuggee extends node_events_1.default {
     }
 }
 exports.Debuggee = Debuggee;
-class TVMDebugSession extends debugadapter_1.LoggingDebugSession {
-    constructor(debuggee) {
-        super();
-        this.debuggee = debuggee;
-        this.debuggee.on('stopOnEntry', () => {
-            this.sendEvent(new debugadapter_1.StoppedEvent('entry', TVMDebugSession.threadID));
-        });
-        this.debuggee.on('stopOnBreakpoint', () => {
-            this.sendEvent(new debugadapter_1.StoppedEvent('breakpoint', TVMDebugSession.threadID));
-        });
-        this.debuggee.on('stopOnStep', () => {
-            this.sendEvent(new debugadapter_1.StoppedEvent('step', TVMDebugSession.threadID));
-        });
-        this.debuggee.on('end', () => {
-            this.sendEvent(new debugadapter_1.TerminatedEvent());
-        });
-        this.debuggee.on('output', (s) => {
-            this.sendEvent(new debugadapter_1.OutputEvent(s + '\n', 'stdout'));
-        });
-    }
-    initializeRequest(response, args) {
-        response.body = response.body || {};
-        const b = response.body;
-        b.supportsConfigurationDoneRequest = false;
-        b.supportsFunctionBreakpoints = false;
-        b.supportsConditionalBreakpoints = false;
-        b.supportsHitConditionalBreakpoints = false;
-        b.supportsEvaluateForHovers = false;
-        b.supportsStepBack = false;
-        b.supportsSetVariable = false;
-        b.supportsRestartFrame = false;
-        b.supportsGotoTargetsRequest = false;
-        b.supportsStepInTargetsRequest = false;
-        b.supportsCompletionsRequest = false;
-        b.supportsModulesRequest = false;
-        b.supportsRestartRequest = false;
-        b.supportsValueFormattingOptions = false;
-        b.supportsExceptionInfoRequest = false;
-        b.supportTerminateDebuggee = false;
-        b.supportSuspendDebuggee = false;
-        b.supportsDelayedStackTraceLoading = false;
-        b.supportsLoadedSourcesRequest = true;
-        b.supportsLogPoints = false;
-        b.supportsTerminateThreadsRequest = false;
-        b.supportsSetExpression = false;
-        b.supportsTerminateRequest = false;
-        b.supportsDataBreakpoints = false;
-        b.supportsReadMemoryRequest = false;
-        b.supportsWriteMemoryRequest = false;
-        b.supportsDisassembleRequest = false;
-        b.supportsCancelRequest = false;
-        b.supportsBreakpointLocationsRequest = true;
-        b.supportsClipboardContext = false;
-        b.supportsSteppingGranularity = false;
-        b.supportsInstructionBreakpoints = false;
-        b.supportsExceptionFilterOptions = false;
-        b.supportsSingleThreadExecutionRequests = false;
-        this.sendResponse(response);
-        this.sendEvent(new debugadapter_1.InitializedEvent());
-    }
-    loadedSourcesRequest(response, args, request) {
-        response.body = response.body || {};
-        response.body.sources = this.debuggee.getAvailableSourcePaths().map(v => ({
-            path: v,
-            name: (0, node_path_1.basename)(v),
-        }));
-        this.sendResponse(response);
-    }
-    breakpointLocationsRequest(response, args, request) {
-        response.body = response.body || {};
-        const path = args.source.path;
-        if (path === undefined) {
-            this.sendErrorResponse(response, {
-                id: 1001,
-                format: 'No path',
-            });
-            return;
-        }
-        response.body.breakpoints = this.debuggee.getAvailableLines(path).filter(l => l >= args.line && l <= (args.endLine ?? args.line)).map(l => ({
-            line: l,
-        }));
-        this.sendResponse(response);
-    }
-    launchRequest(response, args, request) {
-        debugadapter_1.logger.setup(debugadapter_1.Logger.LogLevel.Log);
-        this.debuggee.start(!args.noDebug, true);
-        this.sendResponse(response);
-    }
-    attachRequest(response, args, request) {
-        this.launchRequest(response, args, request);
-    }
-    setBreakPointsRequest(response, args, request) {
-        const path = args.source.path;
-        if (path === undefined) {
-            this.sendErrorResponse(response, {
-                id: 1001,
-                format: 'No path',
-            });
-            return;
-        }
-        const breakpoints = args.breakpoints;
-        if (breakpoints === undefined) {
-            this.sendErrorResponse(response, {
-                id: 1002,
-                format: 'No breakpoints',
-            });
-            return;
-        }
-        this.debuggee.clearBreakpoints(path);
-        const bps = [];
-        for (const bp of breakpoints) {
-            const sbp = this.debuggee.setBreakpoint(path, bp.line);
-            bps.push({
-                id: sbp.id,
-                line: sbp.line,
-                verified: sbp.verified,
-            });
-        }
-        response.body = {
-            breakpoints: bps,
-        };
-        this.sendResponse(response);
-    }
-    threadsRequest(response, request) {
-        response.body = {
-            threads: [
-                new debugadapter_1.Thread(TVMDebugSession.threadID, 'main'),
-            ],
-        };
-        this.sendResponse(response);
-    }
-    continueRequest(response, args, request) {
-        this.debuggee.continue();
-        this.sendResponse(response);
-    }
-    nextRequest(response, args, request) {
-        this.debuggee.step();
-        this.sendResponse(response);
-    }
-    stepInRequest(response, args, request) {
-        this.debuggee.step();
-        this.sendResponse(response);
-    }
-    stepOutRequest(response, args, request) {
-        this.debuggee.step();
-        this.sendResponse(response);
-    }
-    stackTraceRequest(response, args, request) {
-        response.body = response.body || {};
-        const sme = this.debuggee.currentSourceMapEntry();
-        if (sme === undefined) {
-            response.body.stackFrames = [];
-            response.body.totalFrames = 0;
-            this.sendResponse(response);
-            return;
-        }
-        response.body.totalFrames = 1;
-        if (args.startFrame ?? 0 > 0) {
-            response.body.stackFrames = [];
-            this.sendResponse(response);
-            return;
-        }
-        response.body.stackFrames = [{
-                id: TVMDebugSession.stackFrameID,
-                name: 'func',
-                line: sme.line,
-                column: 0,
-                source: {
-                    name: (0, node_path_1.basename)(sme.path),
-                    path: sme.path,
-                },
-            }];
-        this.sendResponse(response);
-    }
-    scopesRequest(response, args, request) {
-        response.body = response.body || {};
-        const sme = this.debuggee.currentSourceMapEntry();
-        if (sme === undefined) {
-            response.body.scopes = [];
-            this.sendResponse(response);
-            return;
-        }
-        response.body.scopes = [{
-                name: 'Locals',
-                variablesReference: TVMDebugSession.variablesReference,
-                expensive: false,
-            }];
-        this.sendResponse(response);
-    }
-    variablesRequest(response, args, request) {
-        response.body = response.body || {};
-        response.body.variables = [];
-        const sme = this.debuggee.currentSourceMapEntry();
-        if (sme === undefined) {
-            this.sendResponse(response);
-            return;
-        }
-        const stack = this.debuggee.getStack();
-        for (let i = 0; i < sme.variables.length; i++) {
-            response.body.variables.push({
-                name: sme.variables[i],
-                value: tupleItemToString(stack[i]),
-                type: stack[i].type,
-                variablesReference: 0,
-            });
-        }
-        response.body.variables.sort((a, b) => (a.name < b.name) ? -1 : (a.name > b.name ? 1 : 0));
-        this.sendResponse(response);
-    }
-    disconnectRequest(response, args, request) {
-        if (args.restart) {
-            this.sendErrorResponse(response, {
-                id: 1003,
-                format: 'Cannot restart',
-            });
-        }
-        else {
-            this.sendResponse(response);
-        }
-    }
-}
-exports.TVMDebugSession = TVMDebugSession;
-TVMDebugSession.threadID = 1;
-TVMDebugSession.stackFrameID = 1;
-TVMDebugSession.variablesReference = 1;
-function tupleItemToString(ti) {
-    switch (ti.type) {
-        case 'int':
-            return ti.value.toString();
-        case 'null':
-            return 'null';
-        case 'nan':
-            return 'NaN';
-        case 'cell':
-        case 'slice':
-        case 'builder':
-            return ti.cell.toBoc().toString('base64');
-        case 'tuple':
-            return `[${ti.items.map(v => tupleItemToString(v)).join(', ')}]`;
-    }
-}

package/dist/debugger/TVMDebugSession.d.ts

@@ -0,0 +1,26 @@
+import { LoggingDebugSession } from "@vscode/debugadapter";
+import { Debuggee } from "./Debuggee";
+import { DebugProtocol } from "@vscode/debugprotocol";
+export declare class TVMDebugSession extends LoggingDebugSession {
+    static readonly threadID = 1;
+    static readonly stackFrameID = 1;
+    static readonly localVariablesReference = 1;
+    static readonly globalVariablesReference = 2;
+    debuggee: Debuggee;
+    constructor(debuggee: Debuggee);
+    protected initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void;
+    protected loadedSourcesRequest(response: DebugProtocol.LoadedSourcesResponse, args: DebugProtocol.LoadedSourcesArguments, request?: DebugProtocol.Request | undefined): void;
+    protected breakpointLocationsRequest(response: DebugProtocol.BreakpointLocationsResponse, args: DebugProtocol.BreakpointLocationsArguments, request?: DebugProtocol.Request | undefined): void;
+    protected launchRequest(response: DebugProtocol.LaunchResponse, args: DebugProtocol.LaunchRequestArguments, request?: DebugProtocol.Request | undefined): void;
+    protected attachRequest(response: DebugProtocol.AttachResponse, args: DebugProtocol.AttachRequestArguments, request?: DebugProtocol.Request | undefined): void;
+    protected setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments, request?: DebugProtocol.Request | undefined): void;
+    protected threadsRequest(response: DebugProtocol.ThreadsResponse, request?: DebugProtocol.Request | undefined): void;
+    protected continueRequest(response: DebugProtocol.ContinueResponse, args: DebugProtocol.ContinueArguments, request?: DebugProtocol.Request | undefined): void;
+    protected nextRequest(response: DebugProtocol.NextResponse, args: DebugProtocol.NextArguments, request?: DebugProtocol.Request | undefined): void;
+    protected stepInRequest(response: DebugProtocol.StepInResponse, args: DebugProtocol.StepInArguments, request?: DebugProtocol.Request | undefined): void;
+    protected stepOutRequest(response: DebugProtocol.StepOutResponse, args: DebugProtocol.StepOutArguments, request?: DebugProtocol.Request | undefined): void;
+    protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments, request?: DebugProtocol.Request | undefined): void;
+    protected scopesRequest(response: DebugProtocol.ScopesResponse, args: DebugProtocol.ScopesArguments, request?: DebugProtocol.Request | undefined): void;
+    protected variablesRequest(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments, request?: DebugProtocol.Request | undefined): void;
+    protected disconnectRequest(response: DebugProtocol.DisconnectResponse, args: DebugProtocol.DisconnectArguments, request?: DebugProtocol.Request | undefined): void;
+}