Initial Surfer support

example/.vscode/settings.json

@@ -3,6 +3,9 @@
         "${workspaceFolder}/design_sim"
     ],
     "rtlDebugger.watchList": [
+        {
+            "id": "top data"
+        },
         {
             "id": "top data"
         }

package.json

@@ -175,6 +175,12 @@
         "command": "rtlDebugger.browseWaveforms",
         "category": "RTL Debugger",
         "title": "Browse Waveforms"
+      },
+      {
+        "command": "rtlDebugger.addToWaveform",
+        "category": "RTL Debugger",
+        "title": "Add to Waveform",
+        "icon": "$(keybindings-add)"
       }
     ],
     "viewsContainers": {
@@ -319,6 +325,11 @@
           "command": "rtlDebugger.unWatchVariable",
           "when": "view == rtlDebugger.sidebar && viewItem =~ /inWatchList/",
           "group": "inline"
+        },
+        {
+          "command": "rtlDebugger.addToWaveform",
+          "when": "view == rtlDebugger.sidebar && viewItem =~ /variable/",
+          "group": "inline"
         }
       ],
       "rtlDebugger.setRadix": [

src/debug/session.ts

@@ -99,6 +99,7 @@ export class Session {
             onRecv: async (serverPacket) => {},
             onDone: async () => {},
         };
+        this.secondaryLinks.push(secondaryLink)
         return secondaryLink;
     }
 

src/debugger.ts

@@ -4,6 +4,7 @@ import * as vscode from 'vscode';
 import { NodeStreamLink } from './cxxrtl/link';
 import { StatusBarItem } from './ui/status';
 import { Session } from './debug/session';
+import { WaveformProvider } from './ui/waveform';
 
 export enum CXXRTLSimulationStatus {
     Paused = 'paused',
@@ -21,6 +22,7 @@ export class CXXRTLDebugger {
     private statusBarItem: StatusBarItem;
     private terminal: vscode.Terminal | null = null;
     session: Session | null = null;
+    waveformProvider: WaveformProvider | null = null;
 
     // Session properties.
 

src/extension.ts

@@ -12,6 +12,8 @@ import { WaveformProvider } from './ui/waveform';
 export function activate(context: vscode.ExtensionContext) {
     const rtlDebugger = new CXXRTLDebugger();
 
+    console.log('Attached');
+
     const sidebarTreeDataProvider = new sidebar.TreeDataProvider(rtlDebugger);
     const sidebarTreeView = vscode.window.createTreeView('rtlDebugger.sidebar', {
         treeDataProvider: sidebarTreeDataProvider
@@ -75,6 +77,12 @@ export function activate(context: vscode.ExtensionContext) {
         }
     }));
 
+    context.subscriptions.push(vscode.commands.registerCommand('rtlDebugger.addToWaveform', (treeItem) => {
+        if (rtlDebugger.waveformProvider) {
+            rtlDebugger.waveformProvider.addVariable(treeItem.designation.variable)
+        }
+    }));
+
     context.subscriptions.push(vscode.commands.registerCommand('rtlDebugger.setRadix.2', (treeItem) =>
         globalVariableOptions.update(treeItem.designation.variable.cxxrtlIdentifier, { radix: 2 })));
     context.subscriptions.push(vscode.commands.registerCommand('rtlDebugger.setRadix.8', (treeItem) =>
@@ -89,7 +97,10 @@ export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(vscode.commands.registerCommand('rtlDebugger.unWatchVariable', (treeItem) =>
         globalWatchList.remove(treeItem.metadata.index)));
 
+
+    console.log('Registering rtlDebugger.browseWaveforms');
     context.subscriptions.push(vscode.commands.registerCommand('rtlDebugger.browseWaveforms', () => {
+        console.log('Running browseWaveforms');
         const webviewPanel = vscode.window.createWebviewPanel(
             'rtlDebugger.waveforms',
             'Waveforms', {
@@ -99,7 +110,8 @@ export function activate(context: vscode.ExtensionContext) {
                 retainContextWhenHidden: true,
             });
         const bundleRoot = vscode.Uri.joinPath(context.extensionUri, 'out/');
-        context.subscriptions.push(new WaveformProvider(rtlDebugger, webviewPanel, bundleRoot));
+        rtlDebugger.waveformProvider = new WaveformProvider(rtlDebugger, webviewPanel, bundleRoot)
+        context.subscriptions.push(rtlDebugger.waveformProvider);
     }));
 
     // For an unknown reason, the `vscode.open` command (which does the exact same thing) ignores the options.

src/model/variable.ts

@@ -44,6 +44,10 @@ export abstract class Variable {
     get cxxrtlIdentifier(): string {
         return this.fullName.join(' ');
     }
+
+    get wcpIdentifier(): string {
+        return this.fullName.join(".");
+    }
 }
 
 export class ScalarVariable extends Variable {

src/surfer/embed.ts

@@ -1,11 +1,12 @@
 import libsurferInit, * as libsurfer from 'libsurfer';
 
-import type { ExtensionToWebviewMessage, WebviewToExtensionMessage } from '../ui/waveform';
+import { ClientPacketString, type ExtensionToWebviewMessage, type WebviewToExtensionMessage } from '../ui/waveform';
 
 function libsurferInjectMessage(message: any) {
     libsurfer.inject_message(JSON.stringify(message));
 }
 
+
 document.addEventListener('DOMContentLoaded', async () => {
     const vscode = acquireVsCodeApi();
     const canvas = <HTMLCanvasElement>document.getElementById('canvas');
@@ -19,17 +20,52 @@ document.addEventListener('DOMContentLoaded', async () => {
     });
 
     const postMessage = <(message: WebviewToExtensionMessage) => void>vscode.postMessage;
-    window.addEventListener('message', (event: MessageEvent<ExtensionToWebviewMessage>) => {
+    window.addEventListener('message', async (event: MessageEvent<ExtensionToWebviewMessage>) => {
         const message = event.data;
-        console.error('[RTL Debugger] [surferEmbed] Unhandled extension to webview message', message);
+        if (message.type === 'cxxrtl_scmessage') {
+            await libsurfer.on_cxxrtl_sc_message(message.message.inner);
+        } else if (message.type === 'wcp_cs_message') {
+            await libsurfer.handle_wcp_cs_message(message.message);
+        } else {
+            console.error('[RTL Debugger] [surferEmbed] Unhandled extension to webview message', message);
+        }
     });
 
+    const handle_cxxrtl_cs_messages = async () => {
+        while (true) {
+            const message = await libsurfer.cxxrtl_cs_message();
+            if (message) {
+                postMessage({type: 'cxxrtl_csmessage', message: new ClientPacketString(message)});
+            } else {
+                throw Error('Got an undefined message from Surfer. Its client probably disconnected');
+            }
+        }
+    };
+
+    const handle_wcp_sc_messages = async () => {
+        while (true) {
+            const message = await libsurfer.next_wcp_sc_message();
+            if (message) {
+                console.log("[WCP] Receiving wcp sc message: {message}")
+                postMessage({type: 'wcp_sc_message', message: message});
+            } else {
+                throw Error('Got an undefined message from Surfer. Its client probably disconnected');
+            }
+        }
+    };
+
     try {
         await libsurferInit();
         await new libsurfer.WebHandle().start(canvas);
 
+        handle_cxxrtl_cs_messages();
+        handle_wcp_sc_messages();
+
+        await libsurfer.start_cxxrtl();
+        await libsurfer.start_wcp();
+
         libsurferInjectMessage('ToggleMenu'); // turn off menu
-        libsurferInjectMessage('ToggleStatusBar'); // turn off status bar
+        libsurferInjectMessage('ToggleStatusbar'); // turn off status bar
         libsurferInjectMessage('ToggleSidePanel');
         libsurferInjectMessage({ SelectTheme: 'dark+' }); // pick VS Code like theme
 

src/ui/sidebar.ts

@@ -203,10 +203,10 @@ class ScopeTreeItem extends TreeItem {
         for (const variable of variables) {
             if (variable instanceof ScalarVariable) {
                 children.push(new ScalarTreeItem(this.provider, variable.designation(),
-                    variable.width > 1 ? 'canWatch|canSetRadix' : 'canWatch'));
+                    variable.width > 1 ? 'canWatch|canSetRadix|variable' : 'canWatch|variable'));
             }
             if (variable instanceof MemoryVariable) {
-                children.push(new ArrayTreeItem(this.provider, variable.designation(), 'canWatch|canSetRadix'));
+                children.push(new ArrayTreeItem(this.provider, variable.designation(), 'canWatch|canSetRadix|variable'));
             }
         }
         return children;

src/ui/waveform.ts

@@ -3,15 +3,32 @@
 import { CXXRTLDebugger } from '../debugger';
 // @ts-ignore
 import embedHtml from '../surfer/embed.html';
+import { ILink, Packet } from '../cxxrtl/link';
+import { ClientPacket } from '../cxxrtl/proto';
+import { Variable } from '../model/variable';
+
+export class ClientPacketString {
+    constructor(public inner: string) { }
+}
+export class ServerPacketString {
+    constructor(public inner: string) { }
+}
+
 
 export type ExtensionToWebviewMessage =
-| { type: 'restore', state: any }
-;
+    | { type: 'restore', state: any }
+    // TODO: Proper type here
+    | { type: 'cxxrtl_scmessage', message: ServerPacketString }
+    | { type: 'wcp_cs_message', message: string }
+    ;
 
 export type WebviewToExtensionMessage =
-| { type: 'ready' }
-| { type: 'crash', error: any }
-;
+    | { type: 'ready' }
+    | { type: 'crash', error: any }
+    // TODO: Proper type here
+    | { type: 'cxxrtl_csmessage', message: ClientPacketString }
+    | { type: 'wcp_sc_message', message: string }
+    ;
 
 export class WaveformProvider {
     constructor(
@@ -23,6 +40,19 @@
             this.webview.asWebviewUri(bundleRoot).toString());
         this.webview.onDidReceiveMessage(this.processMessage.bind(this));
         this.webview.html = webviewHtml;
+        const debuggerLink = rtlDebugger.session?.createSecondaryLink();
+
+        // TODO: Correct way to handle errors?
+        if (debuggerLink) {
+            this.debuggerLink = debuggerLink;
+            this.debuggerLink.onRecv = async (message) => {
+                console.log("Receving scmessage ", message.asString());
+                // console.log("Running on recv for ", message)
+                await this.sendMessage({ type: "cxxrtl_scmessage", message: new ServerPacketString(message.asString()) })
+            };
+        } else {
+            throw new Error('Failed to create secondary debugger link');
+        }
     }
 
     dispose() {
@@ -45,8 +75,26 @@
             console.log('[RTL Debugger] [WaveformProvider] Ready');
         } else if (message.type === 'crash') {
             console.log('[RTL Debugger] [WaveformProvider] Crash:', message.error);
+        } else if (message.type == 'cxxrtl_csmessage') {
+            console.log('[RTL Debugger] [WaveformProvider] Got CSMessage', message.message);
+            const packet: Packet<ClientPacket> = Packet.fromString(message.message.inner);
+            await this.debuggerLink.send(packet);
+        } else if (message.type == 'wcp_sc_message') {
+            console.log('[RTL Debugger] [WaveformProvider] Got WCP SC message', message.message);
         } else {
             console.error('[RTL Debugger] [WaveformProvider] Unhandled webview to extension message:', message);
         }
     }
+
+    async addVariable(variable: Variable) {
+        // TODO: How should we handle the callbacks here?
+        const message = JSON.stringify({
+            type: "command",
+            command: "add_variables",
+            names: [variable.wcpIdentifier]
+        })
+        this.sendMessage({type: 'wcp_cs_message', message})
+    }
+
+    private debuggerLink: ILink;
 }