wasm-idle 0.3.1 → 0.4.0

package/README.md

@@ -2,8 +2,10 @@
 
 ![wasm-idle](static/image.jpeg)
 
-Executes C++, Python Code with working stdio.
+Executes C++, Python, and Java code with working stdio.
 
 Refer to src/lib/clang.
 
-Powered by [wasm-clang](https://github.com/binji/wasm-clang) and Pyodide.
+Java uses TeaVM's browser compiler/runtime. TeaVM compiler/runtime/classlib assets are bundled under `static/teavm/` by default, and the asset base URL can be overridden with `PUBLIC_TEAVM_BASE_URL`.
+
+Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, and TeaVM.

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;
@@ -50,7 +52,8 @@ export default class App {
     constructor(module: WebAssembly.Module, memfs: MemFS, name: string, ...args: string[]);
     run(): Promise<boolean | undefined>;
     proc_exit(code: number): void;
-    __wasm_idle_debug_enter(functionId: number): number;
+    private pauseDebugSession;
+    __wasm_idle_debug_enter(functionId: number, line: number): number;
     __wasm_idle_debug_leave(functionId: number): number;
     __wasm_idle_debug_value_num(functionId: number, slot: number, value: number): number;
     __wasm_idle_debug_value_bool(functionId: number, slot: number, value: number): number;

package/dist/clang/app.js

@@ -68,119 +68,9 @@ export default class App {
     proc_exit(code) {
         throw new ProcExit(code);
     }
-    __wasm_idle_debug_enter(functionId) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        session.callDepth += 1;
-        session.currentFunctionId = functionId;
-        session.frames.push({
-            functionId,
-            functionName: session.functionMetadata[functionId] || `fn_${functionId}`,
-            line: 0,
-            values: new Map()
-        });
-        this.trace(`enter(function=${functionId}, depth=${session.callDepth})`);
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_leave(functionId) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        this.trace(`leave(function=${functionId}, depth=${session.callDepth})`);
-        session.callDepth = Math.max(0, session.callDepth - 1);
-        if (session.currentFunctionId === functionId)
-            session.currentFunctionId = 0;
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            if (session.frames[index]?.functionId === functionId) {
-                session.frames.splice(index, 1);
-                break;
-            }
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_num(functionId, slot, value) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_bool(functionId, slot, value) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, value ? 'true' : 'false');
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_addr(functionId, slot, value) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, String(value >>> 0));
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_text(functionId, slot, ptr, len) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        this.mem?.check?.();
-        const text = this.mem?.readStr ? this.mem.readStr(ptr, len) : '?';
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, text);
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_line(functionId, line) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        if (session.resumeSkipActive) {
-            if (functionId === session.resumeSkipFunctionId && line === session.resumeSkipLine) {
-                return ESUCCESS;
-            }
-            session.resumeSkipActive = false;
-            session.resumeSkipFunctionId = 0;
-            session.resumeSkipLine = 0;
-        }
-        let reason = '';
-        if (session.pauseOnEntry)
-            reason = 'entry';
-        else if (session.breakpoints.has(line))
-            reason = 'breakpoint';
-        else if (session.stepArmed)
-            reason = 'step';
-        else if (session.nextLineArmed &&
-            functionId === session.nextLineFunctionId &&
-            line !== session.nextLineLine) {
-            reason = 'nextLine';
-        }
-        else if (session.stepOutArmed && session.callDepth <= session.stepOutDepth) {
-            reason = 'stepOut';
-        }
-        if (!reason)
+    pauseDebugSession(session, functionId, line, reason) {
+        const buffer = session.buffer;
+        if (!buffer)
             return ESUCCESS;
         session.currentFunctionId = functionId;
         session.currentLine = line;
@@ -280,23 +170,32 @@ export default class App {
             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 }))
         });
-        const sequence = Atomics.load(session.buffer, 0);
+        const sequence = Atomics.load(buffer, 0);
         while (true) {
             if (session.interruptBuffer?.[0] === 2)
                 throw new AbortError();
-            Atomics.wait(session.buffer, 0, sequence, 100);
+            Atomics.wait(buffer, 0, sequence, 100);
             if (session.interruptBuffer?.[0] === 2)
                 throw new AbortError();
-            const command = Atomics.exchange(session.buffer, 1, 0);
+            const command = Atomics.exchange(buffer, 1, 0);
             if (command === 1) {
                 session.resumeSkipActive = true;
                 session.resumeSkipFunctionId = session.currentFunctionId;
@@ -329,6 +228,149 @@ export default class App {
             }
         }
     }
+    __wasm_idle_debug_enter(functionId, line) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        session.callDepth += 1;
+        session.currentFunctionId = functionId;
+        session.currentLine = line;
+        session.frames.push({
+            functionId,
+            functionName: session.functionMetadata[functionId] || `fn_${functionId}`,
+            line,
+            values: new Map()
+        });
+        this.trace(`enter(function=${functionId}, line=${line}, depth=${session.callDepth})`);
+        if (session.pauseOnEntry) {
+            return this.pauseDebugSession(session, functionId, line, 'entry');
+        }
+        if (session.stepArmed) {
+            return this.pauseDebugSession(session, functionId, line, 'step');
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_leave(functionId) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        this.trace(`leave(function=${functionId}, depth=${session.callDepth})`);
+        if (session.nextLineArmed && functionId === session.nextLineFunctionId) {
+            session.nextLineArmed = false;
+            session.stepArmed = true;
+        }
+        session.callDepth = Math.max(0, session.callDepth - 1);
+        if (session.currentFunctionId === functionId)
+            session.currentFunctionId = 0;
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            if (session.frames[index]?.functionId === functionId) {
+                session.frames.splice(index, 1);
+                break;
+            }
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_num(functionId, slot, value) {
+        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)
+                continue;
+            frame.values.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_bool(functionId, slot, value) {
+        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)
+                continue;
+            frame.values.set(slot, value ? 'true' : 'false');
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_addr(functionId, slot, value) {
+        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)
+                continue;
+            frame.values.set(slot, String(value >>> 0));
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_text(functionId, slot, ptr, len) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            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)
+                continue;
+            frame.values.set(slot, text);
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_line(functionId, line) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        if (session.resumeSkipActive) {
+            if (functionId === session.resumeSkipFunctionId && line === session.resumeSkipLine) {
+                return ESUCCESS;
+            }
+            session.resumeSkipActive = false;
+            session.resumeSkipFunctionId = 0;
+            session.resumeSkipLine = 0;
+        }
+        let reason = '';
+        if (session.pauseOnEntry)
+            reason = 'entry';
+        else if (session.breakpoints.has(line))
+            reason = 'breakpoint';
+        else if (session.stepArmed)
+            reason = 'step';
+        else if (session.nextLineArmed &&
+            functionId === session.nextLineFunctionId &&
+            line !== session.nextLineLine) {
+            reason = 'nextLine';
+        }
+        else if (session.stepOutArmed && session.callDepth <= session.stepOutDepth) {
+            reason = 'stepOut';
+        }
+        if (!reason)
+            return ESUCCESS;
+        return this.pauseDebugSession(session, functionId, line, reason);
+    }
     environ_sizes_get(environ_count_out, environ_buf_size_out) {
         this.mem.check();
         let size = 0;

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,18 +137,21 @@ 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>',
                 '#include <string>',
                 '#include <type_traits>',
                 '#include <vector>',
-                'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_enter"))) void __wasm_idle_debug_enter(int functionId);',
+                'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_enter"))) void __wasm_idle_debug_enter(int functionId, int line);',
                 'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_leave"))) void __wasm_idle_debug_leave(int functionId);',
                 'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_value_num"))) void __wasm_idle_debug_value_num(int functionId, int slot, double value);',
                 'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_value_bool"))) void __wasm_idle_debug_value_bool(int functionId, int slot, int value);',
@@ -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('#') &&
@@ -432,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);
@@ -516,7 +584,7 @@ export default class Clang {
                     nextVariableSlot = 1;
                     currentFunctionVariables = new Map();
                     currentFunctionContainers = new Map();
-                    instrumented.push(`${indent}    __wasm_idle_debug_enter(${currentFunctionId});`);
+                    instrumented.push(`${indent}    __wasm_idle_debug_enter(${currentFunctionId}, ${index + 1});`);
                     const parameterSource = startsInlineFunctionBody
                         ? normalized.slice(normalized.indexOf('(') + 1, normalized.lastIndexOf(')'))
                         : pendingFunctionHeader?.parameters || '';
@@ -629,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;
@@ -689,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();