updating expression evaluation periodically

Author: omarArm

src/desktop/extension.ts

@@ -37,7 +37,6 @@ export const activate = async (context: vscode.ExtensionContext): Promise<void>
     const cpuStatesStatusBarItem = new CpuStatesStatusBarItem();
     // Register the Tree View under the id from package.json
     const liveWatchTreeDataProvider = new LiveWatchTreeDataProvider(context);
-    liveWatchTreeDataProvider.activate();
 
     addToolsToPath(context, BUILTIN_TOOLS_PATHS);
     // Activate components
@@ -47,6 +46,8 @@ export const activate = async (context: vscode.ExtensionContext): Promise<void>
     cpuStates.activate(gdbtargetDebugTracker);
     cpuStatesCommands.activate(context, cpuStates);
     cpuStatesStatusBarItem.activate(context, cpuStates);
+    // Live Watch view
+    liveWatchTreeDataProvider.activate(gdbtargetDebugTracker);
 
     logger.debug('Extension Pack activated');
 };

src/features/cpu-states/cpu-states.ts

@@ -44,6 +44,7 @@ interface SessionCpuStates {
 }
 
 export class CpuStates {
+    // onRefresh event to notify GUI components of the cpu states updates (This is different than that of the periodic refresh timer)
     private readonly _onRefresh: vscode.EventEmitter<number> = new vscode.EventEmitter<number>();
     public readonly onRefresh: vscode.Event<number> = this._onRefresh.event;
 

src/live-watch/live-watch.ts

@@ -1,4 +1,5 @@
 import * as vscode from 'vscode';
+import { GDBTargetDebugSession, GDBTargetDebugTracker } from '../debug-session';
 
 interface LiveWatchNode {
   id: number;
@@ -13,10 +14,12 @@ export class LiveWatchTreeDataProvider implements vscode.TreeDataProvider<LiveWa
 
     private readonly _onDidChangeTreeData = new vscode.EventEmitter<LiveWatchNode | void>();
     readonly onDidChangeTreeData: vscode.Event<LiveWatchNode | void> = this._onDidChangeTreeData.event;
-
+    
     private roots: LiveWatchNode[] = [];
     private _context: vscode.ExtensionContext;
-    
+    private continueEvaluate: boolean = true;
+    public activeSession: GDBTargetDebugSession | undefined;
+
     constructor(private readonly context: vscode.ExtensionContext) {
         this.roots = this.context.globalState.get<LiveWatchNode[]>(this.STORAGE_KEY) ?? [];
         this._context = context;
@@ -39,55 +42,63 @@ export class LiveWatchTreeDataProvider implements vscode.TreeDataProvider<LiveWa
     getNumberOfNodes(): number {
         return this.roots.length;
     }
-    
-    activate() {
+
+    activate(tracker: GDBTargetDebugTracker): void {
+        this.addVSCodeCommands();
+        const onDidChangeActiveDebugSession = tracker.onDidChangeActiveDebugSession((session) => {
+            this.activeSession = session;
+            this.continueEvaluate = false;
+        });
+        const onWillStartSession =  tracker.onWillStartSession(session => this.handleOnWillStartSession(session));
+        this._context.subscriptions.push(onDidChangeActiveDebugSession);
+        this._context.subscriptions.push(onWillStartSession);
+    }
+
+    handleOnWillStartSession(session: GDBTargetDebugSession): void {
+        session.refreshTimer.onRefresh(async (refreshSession) => {
+            this.activeSession = refreshSession;
+            this.refresh()
+        });
+    }
+    addVSCodeCommands() {
         this._context.subscriptions.push(
             vscode.window.registerTreeDataProvider('cmsis-debugger-view', this)
         );
         this._context.subscriptions.push(
             vscode.commands.registerCommand('cmsis-debugger-view.add', async () => {
-                    const expression = await vscode.window.showInputBox({ prompt: 'Expression' });
-                    if (!expression) return;
-                    await this.add(expression);
-                }),
-        
-                vscode.commands.registerCommand('cmsis-debugger-view.clear', async () => {
-                    const confirm = await vscode.window.showWarningMessage('Clear all expressions?', { modal: true }, 'Yes');
-                    if (confirm === 'Yes') await this.clear();
-                }),
-        
-                vscode.commands.registerCommand('cmsis-debugger-view.delete', async (node) => {
-                    if (!node) return;
-                    await this.delete(node);
-                }),
-
-                vscode.commands.registerCommand('cmsis-debugger-view.refresh', () => this.refresh()),
-
-                vscode.commands.registerCommand('cmsis-debugger-view.rename', async (node) => {
-                    if (!node) return;
-                    const expression = await vscode.window.showInputBox({ prompt: 'Expression', value: node.expression });
-                    if (!expression) return;
-                    await this.rename(node, expression);
-                })
-            );
-    }
+                const expression = await vscode.window.showInputBox({ prompt: 'Expression' });
+                if (!expression) return;
+                await this.add(expression);
+            }),
 
+            vscode.commands.registerCommand('cmsis-debugger-view.clear', async () => {
+                const confirm = await vscode.window.showWarningMessage('Clear all expressions?', { modal: true }, 'Yes');
+                if (confirm === 'Yes') await this.clear();
+            }),
+
+            vscode.commands.registerCommand('cmsis-debugger-view.delete', async (node) => {
+                if (!node) return;
+                await this.delete(node);
+            }),
+
+            vscode.commands.registerCommand('cmsis-debugger-view.refresh', () => this.refresh()),
+
+            vscode.commands.registerCommand('cmsis-debugger-view.rename', async (node) => {
+                if (!node) return;
+                const expression = await vscode.window.showInputBox({ prompt: 'Expression', value: node.expression });
+                if (!expression) return;
+                await this.rename(node, expression);
+            })
+        );
+    }
     async evaluate(expression: string): Promise<string> {
-        // get the active debug session
-        const session = vscode.debug.activeDebugSession;
-        if (!session) {
-            return '';
-        }
-        try {
-            // using the 'evaluate' request to get the value of the expression
-            const result = await session.customRequest('evaluate', { expression, context: 'watch' });
-            return result.result;
-        } catch (error) {
-            // Handle errors gracefully by viewing the error message as the value
-            return error instanceof Error ? error.message : String(error);
+        if (!this.activeSession) {
+            return 'No active session';
         }
+        const result = await this.activeSession.evaluateGlobalExpression(expression);
+        return result;
     }
-    
+
     async add(expression: string, parent?: LiveWatchNode) {
         // Create a new node with a unique ID and evaluate its value
         const newNode: LiveWatchNode = {
@@ -126,8 +137,20 @@ export class LiveWatchTreeDataProvider implements vscode.TreeDataProvider<LiveWa
         this.refresh(node);
     }
 
-    refresh(node?: LiveWatchNode) { 
-        this._onDidChangeTreeData.fire(node); 
+    async refresh(node?: LiveWatchNode) {
+        if (node) {
+            node.value = await this.evaluate(node.expression);
+            this._onDidChangeTreeData.fire(node);
+            return;
+        }
+        this._onDidChangeTreeData.fire();
+        for (const n of this.roots) {
+            if (!this.continueEvaluate) {
+                break;
+            }
+            n.value = await this.evaluate(n.expression);
+        }
+        this.continueEvaluate = true;
     }
 
     private async save() {