wasm-idle 0.3.0 → 0.3.1

package/dist/clang/app.js

@@ -198,18 +198,59 @@ export default class App {
             if (variable.kind === 'array') {
                 this.mem?.check?.();
                 const address = Number(frame?.values.get(variable.slot) ?? Number.NaN);
-                if (!Number.isFinite(address) || address <= 0 || !variable.length || !variable.elementKind) {
+                const dimensions = variable.dimensions?.length
+                    ? variable.dimensions
+                    : variable.length
+                        ? [variable.length]
+                        : [];
+                if (!Number.isFinite(address) || address <= 0 || !dimensions.length || !variable.elementKind) {
                     return [{ name: variable.name, value: '?' }];
                 }
-                const previewLength = Math.min(variable.length, 8);
+                const elementStride = variable.elementKind === 'double'
+                    ? 8
+                    : variable.elementKind === 'bool' || variable.elementKind === 'char'
+                        ? 1
+                        : 4;
+                if (dimensions.length === 2) {
+                    const previewRows = Math.min(dimensions[0], 4);
+                    const previewCols = Math.min(dimensions[1], 8);
+                    const rows = [];
+                    for (let row = 0; row < previewRows; row += 1) {
+                        const values = [];
+                        for (let col = 0; col < previewCols; col += 1) {
+                            const offset = address + (row * dimensions[1] + col) * elementStride;
+                            if (variable.elementKind === 'bool') {
+                                values.push(this.mem.read8(offset) ? 'true' : 'false');
+                                continue;
+                            }
+                            if (variable.elementKind === 'char') {
+                                const charCode = this.mem.read8(offset);
+                                values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                                continue;
+                            }
+                            if (variable.elementKind === 'float') {
+                                values.push(`${this.mem.readFloat32(offset)}`);
+                                continue;
+                            }
+                            if (variable.elementKind === 'double') {
+                                values.push(`${this.mem.readFloat64(offset)}`);
+                                continue;
+                            }
+                            values.push(`${this.mem.readInt32(offset)}`);
+                        }
+                        rows.push(`[${values.join(', ')}${dimensions[1] > previewCols ? ', ...' : ''}]`);
+                    }
+                    return [
+                        {
+                            name: variable.name,
+                            value: `[${rows.join(', ')}${dimensions[0] > previewRows ? ', ...' : ''}]`
+                        }
+                    ];
+                }
+                const previewLength = Math.min(dimensions[0], 8);
                 const values = [];
                 for (let index = 0; index < previewLength; index += 1) {
-                    const offset = address +
-                        (variable.elementKind === 'double'
-                            ? index * 8
-                            : variable.elementKind === 'bool' || variable.elementKind === 'char'
-                                ? index
-                                : index * 4);
+                    const offset = address + index * elementStride;
                     if (variable.elementKind === 'bool') {
                         values.push(this.mem.read8(offset) ? 'true' : 'false');
                         continue;
@@ -232,7 +273,7 @@ export default class App {
                 return [
                     {
                         name: variable.name,
-                        value: `[${values.join(', ')}${variable.length > previewLength ? ', ...' : ''}]`
+                        value: `[${values.join(', ')}${dimensions[0] > previewLength ? ', ...' : ''}]`
                     }
                 ];
             }

package/dist/clang/index.js

@@ -306,22 +306,27 @@ export default class Clang {
                         for (const declaration of declarations) {
                             const [left] = declaration.split('=');
                             const declarator = left?.trim() || '';
-                            const arrayMatch = declarator.match(/([A-Za-z_]\w*)\s*\[(\d+)\]\s*$/);
-                            if (arrayMatch) {
+                            const arrayDimensions = [];
+                            for (const match of declarator.matchAll(/\[(\d+)\]/g)) {
+                                arrayDimensions.push(Number(match[1]));
+                            }
+                            const arrayName = declarator.match(/([A-Za-z_]\w*)\s*(?=\[\d+\])/);
+                            if (arrayDimensions.length && arrayName) {
                                 const slot = nextVariableSlot++;
                                 this.debugVariableMetadata[currentFunctionId] = [
                                     ...(this.debugVariableMetadata[currentFunctionId] || []),
                                     {
                                         slot,
-                                        name: arrayMatch[1],
+                                        name: arrayName[1],
                                         kind: 'array',
                                         elementKind: declarationMatch[1],
-                                        length: Number(arrayMatch[2]),
+                                        length: arrayDimensions[0],
+                                        dimensions: arrayDimensions,
                                         fromLine: index + 1,
                                         toLine: Number.MAX_SAFE_INTEGER
                                     }
                                 ];
-                                trailingInstrumentation.push(`${indent}__wasm_idle_debug_value_addr(${currentFunctionId}, ${slot}, (int)((unsigned long long)(${arrayMatch[1]})));`);
+                                trailingInstrumentation.push(`${indent}__wasm_idle_debug_value_addr(${currentFunctionId}, ${slot}, (int)((unsigned long long)(${arrayName[1]})));`);
                                 continue;
                             }
                             if (/[*&]/.test(declarator))
@@ -544,22 +549,29 @@ export default class Clang {
                             instrumented.push(`${indent}    __wasm_idle_debug_emit_${container}(${currentFunctionId}, ${slot}, ${name});`);
                             continue;
                         }
-                        const parameterArrayMatch = cleaned.match(/([A-Za-z_]\w*)\s*\[(\d+)\]\s*$/);
-                        if (parameterArrayMatch && /\b(int|float|double|bool|char)\b/.test(cleaned)) {
+                        const parameterArrayDimensions = [];
+                        for (const match of cleaned.matchAll(/\[(\d+)\]/g)) {
+                            parameterArrayDimensions.push(Number(match[1]));
+                        }
+                        const parameterArrayName = cleaned.match(/([A-Za-z_]\w*)\s*(?=\[\d+\])/);
+                        if (parameterArrayDimensions.length &&
+                            parameterArrayName &&
+                            /\b(int|float|double|bool|char)\b/.test(cleaned)) {
                             const slot = nextVariableSlot++;
                             this.debugVariableMetadata[currentFunctionId] = [
                                 ...(this.debugVariableMetadata[currentFunctionId] || []),
                                 {
                                     slot,
-                                    name: parameterArrayMatch[1],
+                                    name: parameterArrayName[1],
                                     kind: 'array',
                                     elementKind: (cleaned.match(/\b(int|float|double|bool|char)\b/)?.[1] || 'int'),
-                                    length: Number(parameterArrayMatch[2]),
+                                    length: parameterArrayDimensions[0],
+                                    dimensions: parameterArrayDimensions,
                                     fromLine: index + 1,
                                     toLine: Number.MAX_SAFE_INTEGER
                                 }
                             ];
-                            instrumented.push(`${indent}    __wasm_idle_debug_value_addr(${currentFunctionId}, ${slot}, (int)((unsigned long long)(${parameterArrayMatch[1]})));`);
+                            instrumented.push(`${indent}    __wasm_idle_debug_value_addr(${currentFunctionId}, ${slot}, (int)((unsigned long long)(${parameterArrayName[1]})));`);
                             continue;
                         }
                         if (/[*&\[]/.test(cleaned))

package/dist/debug/expression.js

@@ -6,6 +6,7 @@ export function evaluateDebugExpression(expression, variables) {
     const values = new Map();
     for (const variable of variables)
         values.set(variable.name, variable.value);
+    const parsedValues = new Map();
     const tokens = [];
     for (let index = 0; index < source.length;) {
         const character = source[index];
@@ -20,6 +21,11 @@ export function evaluateDebugExpression(expression, variables) {
             index += 1;
             continue;
         }
+        if (character === '[' || character === ']') {
+            tokens.push({ type: 'bracket', value: character });
+            index += 1;
+            continue;
+        }
         const operator = operators.find((candidate) => source.startsWith(candidate, index));
         if (operator) {
             tokens.push({ type: 'operator', value: operator });
@@ -46,6 +52,73 @@ export function evaluateDebugExpression(expression, variables) {
         throw new Error(`unsupported token near "${source.slice(index)}"`);
     }
     let cursor = 0;
+    const parsePreviewValue = (text, start = 0) => {
+        let index = start;
+        while (/\s/.test(text[index] || ''))
+            index += 1;
+        const character = text[index];
+        if (character === '[') {
+            index += 1;
+            const items = [];
+            while (true) {
+                while (/\s/.test(text[index] || ''))
+                    index += 1;
+                if (text[index] === ']')
+                    return { value: items, next: index + 1 };
+                if (text.startsWith('...', index))
+                    throw new Error('unavailable');
+                const item = parsePreviewValue(text, index);
+                items.push(item.value);
+                index = item.next;
+                while (/\s/.test(text[index] || ''))
+                    index += 1;
+                if (text[index] === ',') {
+                    index += 1;
+                    continue;
+                }
+                if (text[index] === ']')
+                    return { value: items, next: index + 1 };
+                throw new Error('unsupported array preview');
+            }
+        }
+        if (character === "'") {
+            const end = text.indexOf("'", index + 1);
+            if (end === -1)
+                throw new Error('unsupported char preview');
+            return { value: text.slice(index + 1, end), next: end + 1 };
+        }
+        if (text.startsWith('true', index))
+            return { value: true, next: index + 4 };
+        if (text.startsWith('false', index))
+            return { value: false, next: index + 5 };
+        const number = text.slice(index).match(/^-?\d+(?:\.\d+)?/);
+        if (number?.[0])
+            return { value: Number(number[0]), next: index + number[0].length };
+        throw new Error('unsupported preview');
+    };
+    const resolveIdentifierValue = (name) => {
+        if (parsedValues.has(name))
+            return parsedValues.get(name);
+        const value = values.get(name);
+        if (value == null || value === '?')
+            throw new Error('unavailable');
+        if (value === 'true' || value === 'false') {
+            const parsed = value === 'true';
+            parsedValues.set(name, parsed);
+            return parsed;
+        }
+        const numeric = Number(value);
+        if (!Number.isNaN(numeric)) {
+            parsedValues.set(name, numeric);
+            return numeric;
+        }
+        if (value.startsWith('[')) {
+            const parsed = parsePreviewValue(value).value;
+            parsedValues.set(name, parsed);
+            return parsed;
+        }
+        throw new Error(`unsupported value for ${name}`);
+    };
     const parsePrimary = () => {
         const token = tokens[cursor];
         if (!token)
@@ -60,15 +133,22 @@ export function evaluateDebugExpression(expression, variables) {
         }
         if (token.type === 'identifier') {
             cursor += 1;
-            const value = values.get(token.value);
-            if (value == null || value === '?')
-                throw new Error('unavailable');
-            if (value === 'true' || value === 'false')
-                return value === 'true';
-            const parsed = Number(value);
-            if (!Number.isNaN(parsed))
-                return parsed;
-            throw new Error(`unsupported value for ${token.value}`);
+            let resolved = resolveIdentifierValue(token.value);
+            while (tokens[cursor]?.type === 'bracket' && tokens[cursor]?.value === '[') {
+                cursor += 1;
+                const index = Number(parseOr());
+                const closing = tokens[cursor];
+                if (!closing || closing.type !== 'bracket' || closing.value !== ']')
+                    throw new Error('missing closing bracket');
+                cursor += 1;
+                if (!Array.isArray(resolved) || !Number.isInteger(index))
+                    throw new Error('unsupported index access');
+                const next = resolved[index];
+                if (next == null)
+                    throw new Error('unavailable');
+                resolved = next;
+            }
+            return resolved;
         }
         if (token.type === 'paren' && token.value === '(') {
             cursor += 1;

package/dist/playground/options.d.ts

@@ -14,6 +14,7 @@ export interface DebugVariableMetadata {
     toLine: number;
     elementKind?: DebugArrayElementKind;
     length?: number;
+    dimensions?: number[];
 }
 export interface DebugFrame {
     functionName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"description": "A simple web app to run C++/Python code in the browser",
 	"license": "MIT",
 	"type": "module",