wasm-idle 0.3.0 → 0.3.2

package/dist/clang/app.d.ts

@@ -18,6 +18,7 @@ interface DebugSession {
     nextLineFunctionId: number;
     nextLineLine: number;
     variableMetadata: Record<number, DebugVariableMetadata[]>;
+    globalVariableMetadata: DebugVariableMetadata[];
     functionMetadata: Record<number, string>;
     frames: Array<{
         functionId: number;
@@ -25,6 +26,7 @@ interface DebugSession {
         line: number;
         values: Map<number, string>;
     }>;
+    globalValues: Map<number, string>;
     onPause?: (event: {
         type: 'pause';
         line: number;

package/dist/clang/app.js

@@ -103,6 +103,10 @@ export default class App {
         const session = this.debugSession;
         if (!session?.buffer)
             return ESUCCESS;
+        if (functionId === 0) {
+            session.globalValues.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
+            return ESUCCESS;
+        }
         for (let index = session.frames.length - 1; index >= 0; index -= 1) {
             const frame = session.frames[index];
             if (frame?.functionId !== functionId)
@@ -116,6 +120,10 @@ export default class App {
         const session = this.debugSession;
         if (!session?.buffer)
             return ESUCCESS;
+        if (functionId === 0) {
+            session.globalValues.set(slot, value ? 'true' : 'false');
+            return ESUCCESS;
+        }
         for (let index = session.frames.length - 1; index >= 0; index -= 1) {
             const frame = session.frames[index];
             if (frame?.functionId !== functionId)
@@ -129,6 +137,10 @@ export default class App {
         const session = this.debugSession;
         if (!session?.buffer)
             return ESUCCESS;
+        if (functionId === 0) {
+            session.globalValues.set(slot, String(value >>> 0));
+            return ESUCCESS;
+        }
         for (let index = session.frames.length - 1; index >= 0; index -= 1) {
             const frame = session.frames[index];
             if (frame?.functionId !== functionId)
@@ -144,6 +156,10 @@ export default class App {
             return ESUCCESS;
         this.mem?.check?.();
         const text = this.mem?.readStr ? this.mem.readStr(ptr, len) : '?';
+        if (functionId === 0) {
+            session.globalValues.set(slot, text);
+            return ESUCCESS;
+        }
         for (let index = session.frames.length - 1; index >= 0; index -= 1) {
             const frame = session.frames[index];
             if (frame?.functionId !== functionId)
@@ -198,18 +214,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,18 +289,27 @@ export default class App {
                 return [
                     {
                         name: variable.name,
-                        value: `[${values.join(', ')}${variable.length > previewLength ? ', ...' : ''}]`
+                        value: `[${values.join(', ')}${dimensions[0] > previewLength ? ', ...' : ''}]`
                     }
                 ];
             }
             const value = frame?.values.get(variable.slot) ?? '?';
             return [{ name: variable.name, value }];
         }) || [];
+        const localNames = new Set(locals.map((variable) => variable.name));
+        const globals = (session.globalVariableMetadata || []).flatMap((variable) => {
+            if (localNames.has(variable.name))
+                return [];
+            if (line < variable.fromLine || line > variable.toLine)
+                return [];
+            const value = session.globalValues?.get(variable.slot) ?? '?';
+            return [{ name: variable.name, value }];
+        }) || [];
         session.onPause?.({
             type: 'pause',
             line,
             reason,
-            locals,
+            locals: [...locals, ...globals],
             callStack: [...session.frames]
                 .reverse()
                 .map((stackFrame) => ({ functionName: stackFrame.functionName, line: stackFrame.line }))

package/dist/clang/index.d.ts

@@ -49,6 +49,7 @@ export default class Clang {
         }[];
     }) => void;
     debugVariableMetadata: Record<number, DebugVariableMetadata[]>;
+    debugGlobalMetadata: DebugVariableMetadata[];
     debugFunctionMetadata: Record<number, string>;
     lastBuildKey: string;
     path: string;

package/dist/clang/index.js

@@ -52,6 +52,7 @@ export default class Clang {
     debugInterruptBuffer;
     onDebugEvent;
     debugVariableMetadata = {};
+    debugGlobalMetadata = [];
     debugFunctionMetadata = {};
     lastBuildKey = '';
     path;
@@ -136,11 +137,14 @@ export default class Clang {
             let nextFunctionId = 1;
             let nextVariableSlot = 1;
             let currentFunctionVariables = new Map();
+            let globalVariables = new Map();
             let currentFunctionContainers = new Map();
             let inBlockComment = false;
             let pendingFunctionHeader;
             this.debugVariableMetadata = {};
+            this.debugGlobalMetadata = [];
             this.debugFunctionMetadata = {};
+            const globalInitialization = [];
             const instrumented = [
                 '#include <map>',
                 '#include <set>',
@@ -235,10 +239,64 @@ export default class Clang {
                     analysisLine = analysisLine.slice(0, lineComment);
                 const normalized = analysisLine.trim();
                 const inFunctionBody = functionDepth > 0 && braceDepth >= functionDepth;
+                const isTopLevelDeclarationContext = functionDepth === 0 &&
+                    braceDepth === 0 &&
+                    !normalized.includes('(') &&
+                    !normalized.startsWith('#');
                 const controlHeaderWithoutInlineBlock = /^(while|if|for)\s*\(/.test(normalized) && !normalized.includes('{');
                 const leadingInstrumentation = [];
                 const trailingInstrumentation = [];
                 const declaredContainerNames = new Set();
+                const globalDeclarationMatch = isTopLevelDeclarationContext &&
+                    normalized.match(/^(?:const\s+)?(?:(?:unsigned|signed)\s+)?(?:(?:short|long long|long)\s+)?(int|float|double|bool|char)\s+(.+);$/);
+                if (globalDeclarationMatch) {
+                    const kind = globalDeclarationMatch[1] === 'bool' ? 'bool' : 'number';
+                    const declarations = [];
+                    let declarationBuffer = '';
+                    let declarationBraceDepth = 0;
+                    for (const character of globalDeclarationMatch[2]) {
+                        if (character === ',' && declarationBraceDepth === 0) {
+                            if (declarationBuffer.trim())
+                                declarations.push(declarationBuffer.trim());
+                            declarationBuffer = '';
+                            continue;
+                        }
+                        if (character === '{')
+                            declarationBraceDepth += 1;
+                        if (character === '}')
+                            declarationBraceDepth = Math.max(0, declarationBraceDepth - 1);
+                        declarationBuffer += character;
+                    }
+                    if (declarationBuffer.trim())
+                        declarations.push(declarationBuffer.trim());
+                    for (const declaration of declarations) {
+                        const [left] = declaration.split('=');
+                        const declarator = left?.trim() || '';
+                        if (/[*&\[]/.test(declarator))
+                            continue;
+                        const name = declarator.match(/([A-Za-z_]\w*)\s*$/)?.[1];
+                        if (!name)
+                            continue;
+                        const slot = nextVariableSlot++;
+                        globalVariables.set(name, {
+                            slot,
+                            kind,
+                            fromLine: index + 1,
+                            toLine: Number.MAX_SAFE_INTEGER
+                        });
+                        this.debugGlobalMetadata = [
+                            ...this.debugGlobalMetadata,
+                            {
+                                slot,
+                                name,
+                                kind,
+                                fromLine: index + 1,
+                                toLine: Number.MAX_SAFE_INTEGER
+                            }
+                        ];
+                        globalInitialization.push(`${kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(0, ${slot}, ${name});`);
+                    }
+                }
                 if (inFunctionBody &&
                     normalized &&
                     !normalized.startsWith('#') &&
@@ -306,22 +364,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))
@@ -427,6 +490,16 @@ export default class Clang {
                                     break;
                                 }
                             }
+                            for (const [name, variable] of globalVariables) {
+                                if (currentFunctionVariables.has(name) || currentFunctionContainers.has(name))
+                                    continue;
+                                const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                                if (new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b`).test(normalized) ||
+                                    new RegExp(`\\b${escapedName}\\s*(?:[+\\-*/%]?=|\\+\\+|--)`).test(normalized) ||
+                                    new RegExp(`&\\s*${escapedName}\\b`).test(normalized)) {
+                                    trailingInstrumentation.push(`${indent}${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(0, ${variable.slot}, ${name});`);
+                                }
+                            }
                         }
                         if (closeIndex > openIndex) {
                             const conditionSource = line.slice(openIndex + 1, closeIndex);
@@ -544,22 +617,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))
@@ -617,10 +697,18 @@ export default class Clang {
                     currentFunctionContainers = new Map();
                 }
             }
+            if (globalInitialization.length) {
+                instrumented.push('struct __wasm_idle_debug_globals_init {');
+                instrumented.push('    __wasm_idle_debug_globals_init() {');
+                instrumented.push(...globalInitialization.map((line) => `        ${line}`));
+                instrumented.push('    }');
+                instrumented.push('} __wasm_idle_debug_globals_init_instance;');
+            }
             source = instrumented.join('\n');
         }
         else {
             this.debugVariableMetadata = {};
+            this.debugGlobalMetadata = [];
         }
         const code = toUtf8(source);
         await this.ready;
@@ -677,8 +765,10 @@ export default class Clang {
             nextLineFunctionId: 0,
             nextLineLine: 0,
             variableMetadata: this.debugVariableMetadata,
+            globalVariableMetadata: this.debugGlobalMetadata,
             functionMetadata: this.debugFunctionMetadata,
             frames: [],
+            globalValues: new Map(),
             onPause: (event) => this.onDebugEvent?.(event)
         };
         const instantiate = +new Date();

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.2",
 	"description": "A simple web app to run C++/Python code in the browser",
 	"license": "MIT",
 	"type": "module",