From c062c772e78c5d41c3903ea306491992057925db Mon Sep 17 00:00:00 2001
From: Philip Langer <planger@eclipsesource.com>
Date: Tue, 27 Feb 2024 21:34:17 +0100
Subject: [PATCH 1/4] Make memory address padding configurable

Introduces VS Code setting for memory address padding with the values
  * Unpadded
  * Minimal padding
  * 32 bit padding
  * 64 bit padding

Fixes #76
---
 package.json                              | 17 ++++++++++++
 src/common/memory-range.ts                |  7 +++--
 src/plugin/manifest.ts                    |  2 ++
 src/plugin/memory-webview-main.ts         |  5 ++--
 src/webview/columns/address-column.tsx    |  8 +++---
 src/webview/components/memory-table.tsx   |  1 +
 src/webview/components/memory-widget.tsx  |  4 +++
 src/webview/components/options-widget.tsx | 24 +++++++++++++---
 src/webview/memory-webview-view.tsx       | 34 ++++++++++++++++++++++-
 src/webview/utils/view-types.ts           | 11 +++++++-
 10 files changed, 99 insertions(+), 14 deletions(-)

diff --git a/package.json b/package.json
index b5cc14b..efaa4fd 100644
--- a/package.json
+++ b/package.json
@@ -220,6 +220,23 @@
           ],
           "description": "Behavior when adding more memory beyond the current view."
         },
+        "memory-inspector.addressPadding": {
+          "type": "string",
+          "enum": [
+            "Minimal",
+            "Unpadded",
+            "32bit",
+            "64bit"
+          ],
+          "default": "Minimal",
+          "enumDescriptions": [
+            "Minimal padding based on the longest address in range.",
+            "Disables padding, presenting addresses as-is.",
+            "Pads addresses to fit within a 32-bit address space.",
+            "Pads addresses to fit within a 64-bit address space."
+          ],
+          "description": "Controls the padding with 0s for memory addresses, enhancing readability by aligning them within a specified bit-width context."
+        },
         "memory-inspector.addressRadix": {
           "type": "number",
           "enum": [
diff --git a/src/common/memory-range.ts b/src/common/memory-range.ts
index 13061da..a76df7d 100644
--- a/src/common/memory-range.ts
+++ b/src/common/memory-range.ts
@@ -85,11 +85,14 @@ export function getRadixMarker(radix: Radix): string {
     return radixPrefixMap[radix];
 }
 
-export function getAddressString(address: bigint, radix: Radix, architecture: Architecture = 32, addPadding = false): string {
-    const paddedLength = addPadding ? Math.ceil(architecture / Math.log2(radix)) : 0;
+export function getAddressString(address: bigint, radix: Radix, paddedLength: number = 0): string {
     return address.toString(radix).padStart(paddedLength, '0');
 }
 
+export function getAddressLength(padding: number, radix: Radix): number {
+    return Math.ceil(padding / Math.log2(radix));
+}
+
 export function toHexStringWithRadixMarker(target: bigint): string {
     return `${getRadixMarker(Radix.Hexadecimal)}${getAddressString(target, Radix.Hexadecimal)}`;
 }
diff --git a/src/plugin/manifest.ts b/src/plugin/manifest.ts
index 46487ff..62b5d7c 100644
--- a/src/plugin/manifest.ts
+++ b/src/plugin/manifest.ts
@@ -48,6 +48,8 @@ export const DEFAULT_GROUPS_PER_ROW: GroupsPerRowOption = 4;
 // Scroll
 export const CONFIG_SCROLLING_BEHAVIOR = 'scrollingBehavior';
 export const DEFAULT_SCROLLING_BEHAVIOR = 'Paginate';
+export const CONFIG_ADDRESS_PADDING = 'addressPadding';
+export const DEFAULT_ADDRESS_PADDING = 'Minimal';
 export const CONFIG_ADDRESS_RADIX = 'addressRadix';
 export const DEFAULT_ADDRESS_RADIX = 16;
 export const CONFIG_SHOW_RADIX_PREFIX = 'showRadixPrefix';
diff --git a/src/plugin/memory-webview-main.ts b/src/plugin/memory-webview-main.ts
index 643d9ef..89ac77c 100644
--- a/src/plugin/memory-webview-main.ts
+++ b/src/plugin/memory-webview-main.ts
@@ -35,7 +35,7 @@ import {
 import { MemoryProvider } from './memory-provider';
 import { outputChannelLogger } from './logger';
 import { VariableRange } from '../common/memory-range';
-import { MemoryViewSettings, ScrollingBehavior } from '../webview/utils/view-types';
+import { AddressPaddingOptions, MemoryViewSettings, ScrollingBehavior } from '../webview/utils/view-types';
 
 interface Variable {
     name: string;
@@ -225,9 +225,10 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
         const visibleColumns = CONFIGURABLE_COLUMNS
             .filter(column => vscode.workspace.getConfiguration(manifest.PACKAGE_NAME).get<boolean>(column, false))
             .map(columnId => columnId.replace('columns.', ''));
+        const addressPadding = AddressPaddingOptions[memoryInspectorConfiguration.get(manifest.CONFIG_ADDRESS_PADDING, manifest.DEFAULT_ADDRESS_PADDING)];
         const addressRadix = memoryInspectorConfiguration.get<number>(manifest.CONFIG_ADDRESS_RADIX, manifest.DEFAULT_ADDRESS_RADIX);
         const showRadixPrefix = memoryInspectorConfiguration.get<boolean>(manifest.CONFIG_SHOW_RADIX_PREFIX, manifest.DEFAULT_SHOW_RADIX_PREFIX);
-        return { title, bytesPerWord, wordsPerGroup, groupsPerRow, scrollingBehavior, visibleColumns, addressRadix, showRadixPrefix };
+        return { title, bytesPerWord, wordsPerGroup, groupsPerRow, scrollingBehavior, visibleColumns, addressPadding, addressRadix, showRadixPrefix };
     }
 
     protected async readMemory(request: DebugProtocol.ReadMemoryArguments): Promise<MemoryReadResult> {
diff --git a/src/webview/columns/address-column.tsx b/src/webview/columns/address-column.tsx
index 382b48a..ec84f0c 100644
--- a/src/webview/columns/address-column.tsx
+++ b/src/webview/columns/address-column.tsx
@@ -16,8 +16,8 @@
 
 import React, { ReactNode } from 'react';
 import { BigIntMemoryRange, getAddressString, getRadixMarker } from '../../common/memory-range';
-import { ColumnContribution, ColumnFittingType } from './column-contribution-service';
-import { Memory, MemoryDisplayConfiguration } from '../utils/view-types';
+import { ColumnContribution, ColumnFittingType, TableRenderOptions } from './column-contribution-service';
+import { Memory } from '../utils/view-types';
 
 export class AddressColumn implements ColumnContribution {
     static ID = 'address';
@@ -28,10 +28,10 @@ export class AddressColumn implements ColumnContribution {
 
     fittingType: ColumnFittingType = 'content-width';
 
-    render(range: BigIntMemoryRange, _: Memory, options: MemoryDisplayConfiguration): ReactNode {
+    render(range: BigIntMemoryRange, _: Memory, options: TableRenderOptions): ReactNode {
         return <span className='memory-start-address'>
             {options.showRadixPrefix && <span className='radix-prefix'>{getRadixMarker(options.addressRadix)}</span>}
-            <span className='address'>{getAddressString(range.startAddress, options.addressRadix)}</span>
+            <span className='address'>{getAddressString(range.startAddress, options.addressRadix, options.effectiveAddressLength)}</span>
         </span>;
     }
 }
diff --git a/src/webview/components/memory-table.tsx b/src/webview/components/memory-table.tsx
index 01fa471..76465ad 100644
--- a/src/webview/components/memory-table.tsx
+++ b/src/webview/components/memory-table.tsx
@@ -101,6 +101,7 @@ interface MemoryTableProps extends TableRenderOptions, MemoryDisplayConfiguratio
     decorations: Decoration[];
     offset: number;
     count: number;
+    effectiveAddressLength: number;
     fetchMemory(partialOptions?: Partial<DebugProtocol.ReadMemoryArguments>): Promise<void>;
     isMemoryFetching: boolean;
     isFrozen: boolean;
diff --git a/src/webview/components/memory-widget.tsx b/src/webview/components/memory-widget.tsx
index 4d75877..179ae2d 100644
--- a/src/webview/components/memory-widget.tsx
+++ b/src/webview/components/memory-widget.tsx
@@ -29,6 +29,7 @@ interface MemoryWidgetProps extends MemoryDisplayConfiguration {
     memoryReference: string;
     offset: number;
     count: number;
+    effectiveAddressLength: number;
     isMemoryFetching: boolean;
     refreshMemory: () => void;
     updateMemoryArguments: (memoryArguments: Partial<DebugProtocol.ReadMemoryArguments>) => void;
@@ -72,6 +73,7 @@ export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidge
                 updateRenderOptions={this.props.updateMemoryDisplayConfiguration}
                 resetRenderOptions={this.props.resetMemoryDisplayConfiguration}
                 refreshMemory={this.props.refreshMemory}
+                addressPadding={this.props.addressPadding}
                 addressRadix={this.props.addressRadix}
                 showRadixPrefix={this.props.showRadixPrefix}
                 toggleColumn={this.props.toggleColumn}
@@ -88,9 +90,11 @@ export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidge
                 groupsPerRow={this.props.groupsPerRow}
                 offset={this.props.offset}
                 count={this.props.count}
+                effectiveAddressLength={this.props.effectiveAddressLength}
                 fetchMemory={this.props.fetchMemory}
                 isMemoryFetching={this.props.isMemoryFetching}
                 scrollingBehavior={this.props.scrollingBehavior}
+                addressPadding={this.props.addressPadding}
                 addressRadix={this.props.addressRadix}
                 showRadixPrefix={this.props.showRadixPrefix}
                 isFrozen={this.props.isFrozen}
diff --git a/src/webview/components/options-widget.tsx b/src/webview/components/options-widget.tsx
index f611bbf..1f3b776 100644
--- a/src/webview/components/options-widget.tsx
+++ b/src/webview/components/options-widget.tsx
@@ -23,16 +23,14 @@ import { OverlayPanel } from 'primereact/overlaypanel';
 import { classNames } from 'primereact/utils';
 import React, { FocusEventHandler, KeyboardEvent, KeyboardEventHandler, MouseEventHandler } from 'react';
 import { TableRenderOptions } from '../columns/column-contribution-service';
-import {
-    SerializedTableRenderOptions,
-} from '../utils/view-types';
+import { AddressPaddingOptions, SerializedTableRenderOptions } from '../utils/view-types';
 import { MultiSelectWithLabel } from './multi-select';
 import { CONFIG_BYTES_PER_WORD_CHOICES, CONFIG_GROUPS_PER_ROW_CHOICES, CONFIG_WORDS_PER_GROUP_CHOICES } from '../../plugin/manifest';
 import { tryToNumber } from '../../common/typescript';
 import { Checkbox } from 'primereact/checkbox';
 
 export interface OptionsWidgetProps
-    extends Omit<TableRenderOptions, 'scrollingBehavior'>,
+    extends Omit<TableRenderOptions, 'scrollingBehavior' | 'effectiveAddressLength'>,
     Required<DebugProtocol.ReadMemoryArguments> {
     title: string;
     updateRenderOptions: (options: Partial<SerializedTableRenderOptions>) => void;
@@ -58,6 +56,7 @@ const enum InputId {
     BytesPerWord = 'word-size',
     WordsPerGroup = 'words-per-group',
     GroupsPerRow = 'groups-per-row',
+    AddressPadding = 'address-padding',
     AddressRadix = 'address-radix',
     ShowRadixPrefix = 'show-radix-prefix',
 }
@@ -321,6 +320,20 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                                 className='advanced-options-dropdown' />
 
                             <h2>Address Format</h2>
+
+                            <label
+                                htmlFor={InputId.AddressPadding}
+                                className='advanced-options-label'
+                            >
+                                Address Padding
+                            </label>
+                            <Dropdown
+                                id={InputId.AddressPadding}
+                                value={this.props.addressPadding}
+                                onChange={this.handleAdvancedOptionsDropdownChange}
+                                options={Object.entries(AddressPaddingOptions).map(([label, value]) => ({ label, value }))}
+                                className="advanced-options-dropdown" />
+
                             <label
                                 htmlFor={InputId.AddressRadix}
                                 className='advanced-options-label'
@@ -416,6 +429,9 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
             case InputId.GroupsPerRow:
                 this.props.updateRenderOptions({ groupsPerRow: tryToNumber(value) ?? value });
                 break;
+            case InputId.AddressPadding:
+                this.props.updateRenderOptions({ addressPadding: value });
+                break;
             case InputId.AddressRadix:
                 this.props.updateRenderOptions({ addressRadix: Number(value) });
                 break;
diff --git a/src/webview/memory-webview-view.tsx b/src/webview/memory-webview-view.tsx
index 241183f..440ab13 100644
--- a/src/webview/memory-webview-view.tsx
+++ b/src/webview/memory-webview-view.tsx
@@ -38,9 +38,11 @@ import { AddressColumn } from './columns/address-column';
 import { DataColumn } from './columns/data-column';
 import { PrimeReactProvider } from 'primereact/api';
 import 'primeflex/primeflex.css';
+import { getAddressLength, getAddressString } from '../common/memory-range';
 
 export interface MemoryAppState extends MemoryState, MemoryDisplayConfiguration {
     title: string;
+    effectiveAddressLength: number;
     decorations: Decoration[];
     columns: ColumnStatus[];
     isFrozen: boolean;
@@ -51,6 +53,7 @@ const MEMORY_DISPLAY_CONFIGURATION_DEFAULTS: MemoryDisplayConfiguration = {
     wordsPerGroup: 1,
     groupsPerRow: 4,
     scrollingBehavior: 'Paginate',
+    addressPadding: 'Min',
     addressRadix: 16,
     showRadixPrefix: true,
 };
@@ -70,6 +73,7 @@ class App extends React.Component<{}, MemoryAppState> {
             memoryReference: '',
             offset: 0,
             count: 256,
+            effectiveAddressLength: 0,
             decorations: [],
             columns: columnContributionService.getColumns(),
             isMemoryFetching: false,
@@ -91,6 +95,15 @@ class App extends React.Component<{}, MemoryAppState> {
         messenger.sendNotification(readyType, HOST_EXTENSION, undefined);
     }
 
+    public componentDidUpdate(_: {}, prevState: MemoryAppState): void {
+        const addressPaddingNeedsUpdate =
+            (this.state.addressPadding === 'Min' && this.state.memory !== prevState.memory)
+            || this.state.addressPadding !== prevState.addressPadding;
+        if (addressPaddingNeedsUpdate) {
+            this.setState({ effectiveAddressLength: this.getEffectiveAddressLength(this.state.memory), });
+        }
+    }
+
     public render(): React.ReactNode {
         return <PrimeReactProvider>
             <MemoryWidget
@@ -101,6 +114,7 @@ class App extends React.Component<{}, MemoryAppState> {
                 offset={this.state.offset ?? 0}
                 count={this.state.count}
                 title={this.state.title}
+                effectiveAddressLength={this.state.effectiveAddressLength}
                 updateMemoryArguments={this.updateMemoryState}
                 updateMemoryDisplayConfiguration={this.updateMemoryDisplayConfiguration}
                 resetMemoryDisplayConfiguration={this.resetMemoryDisplayConfiguration}
@@ -115,6 +129,7 @@ class App extends React.Component<{}, MemoryAppState> {
                 groupsPerRow={this.state.groupsPerRow}
                 wordsPerGroup={this.state.wordsPerGroup}
                 scrollingBehavior={this.state.scrollingBehavior}
+                addressPadding={this.state.addressPadding}
                 addressRadix={this.state.addressRadix}
                 showRadixPrefix={this.state.showRadixPrefix}
             />
@@ -156,9 +171,11 @@ class App extends React.Component<{}, MemoryAppState> {
                 executor => executor.fetchData(completeOptions)
             ));
 
+            const memory = this.convertMemory(response);
+
             this.setState({
                 decorations: decorationService.decorations,
-                memory: this.convertMemory(response),
+                memory,
                 memoryReference: completeOptions.memoryReference,
                 offset: completeOptions.offset,
                 count: completeOptions.count,
@@ -179,6 +196,21 @@ class App extends React.Component<{}, MemoryAppState> {
         return { bytes, address };
     }
 
+    protected getEffectiveAddressLength(memory?: Memory): number {
+        const { addressRadix, addressPadding } = this.state;
+        return addressPadding === 'Min' ? this.getLastAddressLength(memory) : getAddressLength(addressPadding, addressRadix);
+    }
+
+    protected getLastAddressLength(memory?: Memory): number {
+        if (memory === undefined) {
+            return 0;
+        }
+        const rowLength = this.state.bytesPerWord * this.state.wordsPerGroup * this.state.groupsPerRow;
+        const rows = Math.ceil(memory.bytes.length / rowLength);
+        const finalAddress = memory.address + BigInt(((rows - 1) * rowLength));
+        return getAddressString(finalAddress, this.state.addressRadix).length;
+    }
+
     protected toggleColumn = (id: string, active: boolean): void => { this.doToggleColumn(id, active); };
     protected async doToggleColumn(id: string, isVisible: boolean): Promise<void> {
         const columns = isVisible ? await columnContributionService.show(id, this.state) : columnContributionService.hide(id);
diff --git a/src/webview/utils/view-types.ts b/src/webview/utils/view-types.ts
index ba7bc20..6bfa8c6 100644
--- a/src/webview/utils/view-types.ts
+++ b/src/webview/utils/view-types.ts
@@ -33,7 +33,7 @@ export interface Memory {
 export interface SerializedTableRenderOptions extends MemoryDisplayConfiguration {
     columnOptions: Array<{ label: string, doRender: boolean }>;
     endianness: Endianness;
-    bytesPerWord: number;
+    effectiveAddressLength: number;
 }
 
 export interface Event<T> {
@@ -84,11 +84,20 @@ export interface MemoryDisplayConfiguration {
     wordsPerGroup: number;
     groupsPerRow: GroupsPerRowOption;
     scrollingBehavior: ScrollingBehavior;
+    addressPadding: AddressPadding;
     addressRadix: Radix;
     showRadixPrefix: boolean;
 }
 export type ScrollingBehavior = 'Paginate' | 'Infinite';
 
+export type AddressPadding = 'Min' | number;
+export const AddressPaddingOptions = {
+    'Minimal': 'Min',
+    'Unpadded': 0,
+    '32bit': 32,
+    '64bit': 64,
+} as const;
+
 export interface ColumnVisibilityStatus {
     visibleColumns: string[];
 }

From 8894be92eb9619932a5e7403d1387c0ebc589eca Mon Sep 17 00:00:00 2001
From: Philip Langer <planger@eclipsesource.com>
Date: Fri, 1 Mar 2024 20:40:32 +0100
Subject: [PATCH 2/4] Guard state update

---
 src/webview/memory-webview-view.tsx | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/webview/memory-webview-view.tsx b/src/webview/memory-webview-view.tsx
index 440ab13..2026575 100644
--- a/src/webview/memory-webview-view.tsx
+++ b/src/webview/memory-webview-view.tsx
@@ -100,7 +100,10 @@ class App extends React.Component<{}, MemoryAppState> {
             (this.state.addressPadding === 'Min' && this.state.memory !== prevState.memory)
             || this.state.addressPadding !== prevState.addressPadding;
         if (addressPaddingNeedsUpdate) {
-            this.setState({ effectiveAddressLength: this.getEffectiveAddressLength(this.state.memory), });
+            const effectiveAddressLength = this.getEffectiveAddressLength(this.state.memory);
+            if (this.state.effectiveAddressLength !== effectiveAddressLength) {
+                this.setState({ effectiveAddressLength });
+            }
         }
     }
 

From fe0472f97c38350428f4e4871830588ad57190f4 Mon Sep 17 00:00:00 2001
From: Martin Fleck <mfleck@eclipsesource.com>
Date: Wed, 6 Mar 2024 18:53:18 +0100
Subject: [PATCH 3/4] Apply new wording

---
 package.json | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/package.json b/package.json
index efaa4fd..588366d 100644
--- a/package.json
+++ b/package.json
@@ -184,7 +184,10 @@
           "description": "Default words per group"
         },
         "memory-inspector.groupings.groupsPerRow": {
-          "type": ["string", "number"],
+          "type": [
+            "string",
+            "number"
+          ],
           "enum": [
             "Autofit",
             1,
@@ -230,10 +233,10 @@
           ],
           "default": "Minimal",
           "enumDescriptions": [
-            "Minimal padding based on the longest address in range.",
-            "Disables padding, presenting addresses as-is.",
-            "Pads addresses to fit within a 32-bit address space.",
-            "Pads addresses to fit within a 64-bit address space."
+            "Pads to largest address width in loaded range.",
+            "Disables padding.",
+            "Pads to 32 bits.",
+            "Pads to 64 bits."
           ],
           "description": "Controls the padding with 0s for memory addresses, enhancing readability by aligning them within a specified bit-width context."
         },

From 3106c760d8fa0a6053eec3ae5e1eb81983eb9821 Mon Sep 17 00:00:00 2001
From: Martin Fleck <mfleck@eclipsesource.com>
Date: Wed, 6 Mar 2024 18:55:51 +0100
Subject: [PATCH 4/4] Cannot detect last address length on auto-fit

---
 src/webview/memory-webview-view.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/webview/memory-webview-view.tsx b/src/webview/memory-webview-view.tsx
index 2026575..160e4fe 100644
--- a/src/webview/memory-webview-view.tsx
+++ b/src/webview/memory-webview-view.tsx
@@ -205,7 +205,7 @@ class App extends React.Component<{}, MemoryAppState> {
     }
 
     protected getLastAddressLength(memory?: Memory): number {
-        if (memory === undefined) {
+        if (memory === undefined || this.state.groupsPerRow === 'Autofit') {
             return 0;
         }
         const rowLength = this.state.bytesPerWord * this.state.wordsPerGroup * this.state.groupsPerRow;