Allow to set data breakpoints

media/memory-table.css

@@ -32,6 +32,53 @@
   outline-offset: -1px;
 }
 
+.memory-inspector-table .data-breakpoint {
+  outline: 1px solid var(--vscode-debugIcon-breakpointForeground);
+  outline-offset: 1px;
+}
+
+.memory-inspector-table .data-breakpoint.data-breakpoint-external {
+  outline-style: dashed;
+}
+
+.memory-inspector-table tbody .column-address {
+  position: relative;
+}
+
+.memory-inspector-table tbody .address-status {
+  position: absolute;
+  left: -1px;
+  align-items: center;
+  display: flex;
+  justify-content: center;
+}
+
+.memory-inspector-table tbody .address-status.codicon {
+  font-size: 12px;
+}
+
+.memory-inspector-table tbody .address-status.codicon-debug-breakpoint {
+  color: var(--vscode-debugIcon-breakpointForeground);
+}
+
+.memory-inspector-table tbody .address-status.codicon-debug-stackframe {
+  color: var(--vscode-debugIcon-breakpointCurrentStackframeForeground);
+}
+
+.memory-inspector-table
+  tbody
+  .address-status.codicon-debug-breakpoint.codicon-debug-stackframe:after {
+  content: "\ea71";
+  position: absolute;
+  left: 3px;
+  font-size: 6px;
+  color: var(--vscode-debugIcon-breakpointForeground);
+}
+
+.memory-inspector-table tbody .debug-hit {
+  outline-color: var(--vscode-debugIcon-breakpointCurrentStackframeForeground);
+}
+
 /* == MoreMemorySelect == */
 
 .bytes-select {
@@ -91,7 +138,7 @@
 
 .memory-inspector-table span.p-column-resizer {
   border-right: 2px solid var(--vscode-editor-lineHighlightBorder);
-  transition: border-right .1s ease-out;
+  transition: border-right 0.1s ease-out;
 }
 
 .memory-inspector-table span.p-column-resizer:hover {
@@ -112,7 +159,7 @@
 /* Basic hover formatting (copied from Monaco hovers) */
 .memory-hover {
   min-width: fit-content;
-  max-width: var(--vscode-hover-maxWidth,500px);
+  max-width: var(--vscode-hover-maxWidth, 500px);
   border: 1px solid var(--vscode-editorHoverWidget-border);
   border-radius: 3px;
 
@@ -128,34 +175,40 @@
   border-collapse: collapse;
   border-style: hidden;
 }
+
 .memory-hover table caption {
   padding: 4px;
   border-bottom: 1px solid var(--vscode-editorHoverWidget-border);
 }
+
 .memory-hover td {
   border: 1px solid var(--vscode-editorHoverWidget-border);
   padding: 2px 8px;
 }
+
 .memory-hover td:first-child {
   text-align: right;
 }
 
 /* Colors for the hover fields */
-.memory-hover .label-value-pair>.label {
-    color: var(--vscode-debugTokenExpression-string);
-    white-space: nowrap;
+.memory-hover .label-value-pair > .label {
+  color: var(--vscode-debugTokenExpression-string);
+  white-space: nowrap;
 }
-.memory-hover .label-value-pair>.value {
+
+.memory-hover .label-value-pair > .value {
   color: var(--vscode-debugTokenExpression-number);
 }
 
 /* Colors for specific hover fields */
 .memory-hover .address-hover .primary {
   background-color: var(--vscode-list-hoverBackground);
 }
+
 .memory-hover table caption {
   color: var(--vscode-symbolIcon-variableForeground);
 }
+
 .memory-hover .address-hover .value.utf8,
 .memory-hover .data-hover .value.utf8,
 .memory-hover .variable-hover .value.type {

package.json

@@ -446,4 +446,4 @@
   "extensionKind": [
     "ui"
   ]
-}
+}

src/common/breakpoint.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (C) 2024 EclipseSource.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { DebugProtocol } from '@vscode/debugprotocol';
+import { DebugRequestTypes } from './debug-requests';
+
+export interface TrackedDataBreakpoint {
+    type: TrackedBreakpointType;
+    breakpoint: DebugProtocol.DataBreakpoint;
+    /**
+     * The respective response for the breakpoint.
+     */
+    response: DebugProtocol.Breakpoint;
+}
+
+/**
+ * Temp. workaround till we have a proper API for this within VSCode.
+ */
+export interface TrackedDataBreakpoints {
+    /**
+     * Breakpoints set from external contributors.
+     */
+    external: TrackedDataBreakpoint[],
+    /**
+     * Breakpoints set from us.
+     */
+    internal: TrackedDataBreakpoint[]
+}
+
+/**
+ * Temp. workaround till we have a proper API for this within VSCode.
+ */
+export type TrackedBreakpointType = 'internal' | 'external';
+
+export type DataBreakpointInfoArguments = DebugRequestTypes['dataBreakpointInfo'][0];
+export type DataBreakpointInfoResult = DebugRequestTypes['dataBreakpointInfo'][1];
+export type SetDataBreakpointsArguments = DebugRequestTypes['setDataBreakpoints'][0];
+export type SetDataBreakpointsResult = DebugRequestTypes['setDataBreakpoints'][1];

src/common/debug-requests.ts

@@ -25,6 +25,8 @@ export interface DebugRequestTypes {
     'scopes': [DebugProtocol.ScopesArguments, DebugProtocol.ScopesResponse['body']]
     'variables': [DebugProtocol.VariablesArguments, DebugProtocol.VariablesResponse['body']]
     'writeMemory': [DebugProtocol.WriteMemoryArguments, DebugProtocol.WriteMemoryResponse['body']]
+    'dataBreakpointInfo': [DebugProtocol.DataBreakpointInfoArguments, DebugProtocol.DataBreakpointInfoResponse['body']]
+    'setDataBreakpoints': [DebugProtocol.SetDataBreakpointsArguments, DebugProtocol.SetDataBreakpointsResponse['body']]
 }
 
 export interface DebugEvents {
@@ -59,16 +61,28 @@ export function isDebugEvaluateArguments(args: DebugProtocol.EvaluateArguments |
 }
 
 export function isDebugRequest<K extends keyof DebugRequestTypes>(command: K, message: unknown): message is DebugRequest<K, DebugRequestTypes[K][0]> {
-    const assumed = message ? message as DebugProtocol.Request : undefined;
-    return !!assumed && assumed.type === 'request' && assumed.command === command;
+    return isDebugRequestType(message) && message.command === command;
 }
 
 export function isDebugResponse<K extends keyof DebugRequestTypes>(command: K, message: unknown): message is DebugResponse<K, DebugRequestTypes[K][1]> {
-    const assumed = message ? message as DebugProtocol.Response : undefined;
-    return !!assumed && assumed.type === 'response' && assumed.command === command;
+    return isDebugResponseType(message) && message.command === command;
 }
 
 export function isDebugEvent<K extends keyof DebugEvents>(event: K, message: unknown): message is DebugEvents[K] {
+    return isDebugEventType(message) && message.event === event;
+}
+
+export function isDebugRequestType(message: unknown): message is DebugProtocol.Request {
+    const assumed = message ? message as DebugProtocol.Request : undefined;
+    return !!assumed && assumed.type === 'request';
+}
+
+export function isDebugResponseType(message: unknown): message is DebugProtocol.Response {
+    const assumed = message ? message as DebugProtocol.Response : undefined;
+    return !!assumed && assumed.type === 'response';
+}
+
+export function isDebugEventType(message: unknown): message is DebugProtocol.Event {
     const assumed = message ? message as DebugProtocol.Event : undefined;
-    return !!assumed && assumed.type === 'event' && assumed.event === event;
+    return !!assumed && assumed.type === 'event';
 }

src/common/memory-range.ts

@@ -108,6 +108,7 @@ export interface VariableMetadata {
     type?: string;
     /** If applicable, a string representation of the variable's value */
     value?: string;
+    parentVariablesReference?: number;
     isPointer?: boolean;
 }
 

src/common/messaging.ts

@@ -17,7 +17,8 @@
 import type { DebugProtocol } from '@vscode/debugprotocol';
 import type { NotificationType, RequestType } from 'vscode-messenger-common';
 import { URI } from 'vscode-uri';
-import { DebugRequestTypes } from './debug-requests';
+import type { TrackedDataBreakpoints } from './breakpoint';
+import { DebugEvents, DebugRequestTypes } from './debug-requests';
 import { VariablesView } from './external-views';
 import type { VariableRange, WrittenMemory } from './memory-range';
 import { MemoryViewSettings } from './webview-configuration';
@@ -32,6 +33,9 @@ export type ReadMemoryResult = DebugRequestTypes['readMemory'][1];
 export type WriteMemoryArguments = DebugRequestTypes['writeMemory'][0];
 export type WriteMemoryResult = DebugRequestTypes['writeMemory'][1];
 
+export type StoppedEvent = DebugEvents['stopped'];
+export type ContinuedEvent = DebugEvents['continued'];
+
 export type StoreMemoryArguments = MemoryOptions & { proposedOutputName?: string } | VariablesView.IVariablesContext | WebviewContext;
 export type StoreMemoryResult = void;
 
@@ -51,6 +55,9 @@ export const setMemoryViewSettingsType: NotificationType<Partial<MemoryViewSetti
 export const setTitleType: NotificationType<string> = { method: 'setTitle' };
 export const memoryWrittenType: NotificationType<WrittenMemory> = { method: 'memoryWritten' };
 export const sessionContextChangedType: NotificationType<SessionContext> = { method: 'sessionContextChanged' };
+export const setTrackedBreakpointType: NotificationType<TrackedDataBreakpoints> = { method: 'setTrackedBreakpoints' };
+export const notifyStoppedType: NotificationType<StoppedEvent> = { method: 'notifyStoppedType' };
+export const notifyContinuedType: NotificationType<ContinuedEvent> = { method: 'notifyContinuedType' };
 
 // Requests
 export const setOptionsType: RequestType<MemoryOptions, void> = { method: 'setOptions' };

src/common/webview-context.ts

@@ -41,6 +41,15 @@ export interface WebviewVariableContext extends WebviewCellContext {
     variable?: VariableMetadata
 }
 
+export interface WebviewGroupContext extends WebviewCellContext {
+    memoryData?: {
+        group: {
+            startAddress: string;
+            length: number;
+        }
+    }
+}
+
 /**
  * Retrieves the currently visible (configurable) columns from the given {@link WebviewContext}.
  * @returns A string array containing the visible columns ids.
@@ -64,6 +73,14 @@ export function isWebviewContext(args: WebviewContext | unknown): args is Webvie
         && typeof assumed.activeReadArguments?.memoryReference === 'string';
 }
 
+export function isWebviewGroupContext(args: WebviewVariableContext | unknown): args is Required<WebviewGroupContext> {
+    const assumed = args ? args as WebviewGroupContext : undefined;
+    return !!assumed && isWebviewContext(args)
+        && !!assumed.memoryData
+        && (typeof assumed.memoryData.group.startAddress === 'string')
+        && (typeof assumed.memoryData.group.length === 'number');
+}
+
 export function isWebviewVariableContext(args: WebviewVariableContext | unknown): args is Required<WebviewVariableContext> {
     const assumed = args ? args as WebviewVariableContext : undefined;
     return !!assumed && isWebviewContext(args)

src/entry-points/browser/extension.ts

@@ -17,6 +17,8 @@
 import * as vscode from 'vscode';
 import { AdapterRegistry } from '../../plugin/adapter-registry/adapter-registry';
 import { CAdapter } from '../../plugin/adapter-registry/c-adapter';
+import { BreakpointProvider } from '../../plugin/breakpoints/breakpoint-provider';
+import { BreakpointTracker } from '../../plugin/breakpoints/breakpoint-tracker';
 import { ContextTracker } from '../../plugin/context-tracker';
 import { MemoryProvider } from '../../plugin/memory-provider';
 import { MemoryStorage } from '../../plugin/memory-storage';
@@ -27,8 +29,10 @@ export const activate = async (context: vscode.ExtensionContext): Promise<Adapte
     const registry = new AdapterRegistry();
     const sessionTracker = new SessionTracker();
     new ContextTracker(sessionTracker);
+    const breakpointTracker = new BreakpointTracker(sessionTracker);
+    const breakpointProvider = new BreakpointProvider(sessionTracker, breakpointTracker);
     const memoryProvider = new MemoryProvider(registry, sessionTracker);
-    const memoryView = new MemoryWebview(context.extensionUri, memoryProvider, sessionTracker);
+    const memoryView = new MemoryWebview(context.extensionUri, memoryProvider, sessionTracker, breakpointTracker, breakpointProvider);
     const memoryStorage = new MemoryStorage(memoryProvider);
     const cAdapter = new CAdapter(registry);
 

src/entry-points/desktop/extension.ts

@@ -17,6 +17,8 @@
 import * as vscode from 'vscode';
 import { AdapterRegistry } from '../../plugin/adapter-registry/adapter-registry';
 import { CAdapter } from '../../plugin/adapter-registry/c-adapter';
+import { BreakpointProvider } from '../../plugin/breakpoints/breakpoint-provider';
+import { BreakpointTracker } from '../../plugin/breakpoints/breakpoint-tracker';
 import { ContextTracker } from '../../plugin/context-tracker';
 import { MemoryProvider } from '../../plugin/memory-provider';
 import { MemoryStorage } from '../../plugin/memory-storage';
@@ -27,8 +29,10 @@ export const activate = async (context: vscode.ExtensionContext): Promise<Adapte
     const registry = new AdapterRegistry();
     const sessionTracker = new SessionTracker();
     new ContextTracker(sessionTracker);
+    const breakpointTracker = new BreakpointTracker(sessionTracker);
+    const breakpointProvider = new BreakpointProvider(sessionTracker, breakpointTracker);
     const memoryProvider = new MemoryProvider(registry, sessionTracker);
-    const memoryView = new MemoryWebview(context.extensionUri, memoryProvider, sessionTracker);
+    const memoryView = new MemoryWebview(context.extensionUri, memoryProvider, sessionTracker, breakpointTracker, breakpointProvider);
     const memoryStorage = new MemoryStorage(memoryProvider);
     const cAdapter = new CAdapter(registry);
 

src/plugin/adapter-registry/adapter-capabilities.ts

@@ -112,7 +112,7 @@ export class AdapterVariableTracker implements vscode.DebugAdapterTracker {
             if (this.isDesiredVariable(parent) && parent.children?.length) {
                 this.logger.debug('Resolving children of', parent.name);
                 parent.children.forEach(child => {
-                    previous.push(this.variableToVariableRange(child, session));
+                    previous.push(this.variableToVariableRange(child, session, parent));
                 });
             } else {
                 this.logger.debug('Ignoring', parent.name);
@@ -126,7 +126,10 @@ export class AdapterVariableTracker implements vscode.DebugAdapterTracker {
         return candidate.presentationHint !== 'registers' && candidate.name !== 'Registers';
     }
 
-    protected variableToVariableRange(_variable: DebugProtocol.Variable, _session: vscode.DebugSession): Promise<VariableRange | undefined> {
+    protected variableToVariableRange(
+        _variable: DebugProtocol.Variable,
+        _session: vscode.DebugSession,
+        _parent: WithChildren<DebugProtocol.Scope | DebugProtocol.Variable>): Promise<VariableRange | undefined> {
         throw new Error('To be implemented by derived classes!');
     }
 

src/plugin/adapter-registry/c-tracker.ts

@@ -18,7 +18,7 @@ import { DebugProtocol } from '@vscode/debugprotocol';
 import * as vscode from 'vscode';
 import { sendRequest } from '../../common/debug-requests';
 import { toHexStringWithRadixMarker, VariableRange } from '../../common/memory-range';
-import { AdapterVariableTracker, decimalAddress, extractAddress, hexAddress, notADigit } from './adapter-capabilities';
+import { AdapterVariableTracker, decimalAddress, extractAddress, hexAddress, notADigit, WithChildren } from './adapter-capabilities';
 
 export namespace CEvaluateExpression {
     export function sizeOf(expression: string): string {
@@ -35,7 +35,10 @@ export class CTracker extends AdapterVariableTracker {
      * Resolves memory location and size using evaluate requests for `$(variable.name)` and `sizeof(variable.name)`
      * Ignores the presence or absence of variable.memoryReference.
      */
-    protected override async variableToVariableRange(variable: DebugProtocol.Variable, session: vscode.DebugSession): Promise<VariableRange | undefined> {
+    protected override async variableToVariableRange(
+        variable: DebugProtocol.Variable,
+        session: vscode.DebugSession,
+        parent: WithChildren<DebugProtocol.Scope | DebugProtocol.Variable>): Promise<VariableRange | undefined> {
         if (this.currentFrame === undefined || !variable.name) {
             this.logger.debug('Unable to resolve', variable.name,
                 { noName: !variable.name, noFrame: this.currentFrame === undefined });
@@ -66,6 +69,7 @@ export class CTracker extends AdapterVariableTracker {
             endAddress: variableSize === undefined ? undefined : toHexStringWithRadixMarker(address + variableSize),
             value: variable.value,
             type: variable.type,
+            parentVariablesReference: parent.variablesReference,
             isPointer,
         };
         return variableRange;