wasm-idle 0.3.2 → 0.4.1

package/README.md

@@ -2,8 +2,28 @@
 
 ![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`.
+
+`Terminal` and `playground(...).load(...)` support either the legacy shared `path`/`rootUrl` or per-runtime asset config:
+
+```ts
+import type { PlaygroundRuntimeAssets } from 'wasm-idle';
+
+const runtimeAssets: PlaygroundRuntimeAssets = {
+	rootUrl: 'https://cdn.example.com/repl',
+	python: {
+		loader: async ({ asset }) => ({ url: `https://cdn.example.com/repl/pyodide/${asset}` })
+	},
+	java: {
+		baseUrl: 'https://cdn.example.com/repl/teavm/'
+	}
+};
+```
+
+Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
+
+Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, and TeaVM.

package/dist/clang/app.d.ts

@@ -52,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,139 +68,15 @@ 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;
-        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)
+    pauseDebugSession(session, functionId, line, reason) {
+        const buffer = session.buffer;
+        if (!buffer)
             return ESUCCESS;
         session.currentFunctionId = functionId;
         session.currentLine = line;
-        const frame = [...session.frames].reverse().find((candidate) => candidate.functionId === functionId);
+        const frame = [...session.frames]
+            .reverse()
+            .find((candidate) => candidate.functionId === functionId);
         if (frame)
             frame.line = line;
         session.pauseOnEntry = false;
@@ -219,7 +95,10 @@ export default class App {
                     : variable.length
                         ? [variable.length]
                         : [];
-                if (!Number.isFinite(address) || address <= 0 || !dimensions.length || !variable.elementKind) {
+                if (!Number.isFinite(address) ||
+                    address <= 0 ||
+                    !dimensions.length ||
+                    !variable.elementKind) {
                     return [{ name: variable.name, value: '?' }];
                 }
                 const elementStride = variable.elementKind === 'double'
@@ -241,7 +120,9 @@ export default class App {
                             }
                             if (variable.elementKind === 'char') {
                                 const charCode = this.mem.read8(offset);
-                                values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                                values.push(charCode >= 0x20 && charCode <= 0x7e
+                                    ? `'${String.fromCharCode(charCode)}'`
+                                    : `${charCode}`);
                                 continue;
                             }
                             if (variable.elementKind === 'float') {
@@ -273,7 +154,9 @@ export default class App {
                     }
                     if (variable.elementKind === 'char') {
                         const charCode = this.mem.read8(offset);
-                        values.push(charCode >= 0x20 && charCode <= 0x7e ? `'${String.fromCharCode(charCode)}'` : `${charCode}`);
+                        values.push(charCode >= 0x20 && charCode <= 0x7e
+                            ? `'${String.fromCharCode(charCode)}'`
+                            : `${charCode}`);
                         continue;
                     }
                     if (variable.elementKind === 'float') {
@@ -312,16 +195,19 @@ export default class App {
             locals: [...locals, ...globals],
             callStack: [...session.frames]
                 .reverse()
-                .map((stackFrame) => ({ functionName: stackFrame.functionName, line: stackFrame.line }))
+                .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;
@@ -354,6 +240,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

@@ -2,6 +2,7 @@ import type { DebugVariable, DebugVariableMetadata } from '../playground/options
 import App from './app';
 import { MemFS } from './memory';
 import { type Writable } from 'svelte/store';
+type ClangSourceLanguage = 'C' | 'CPP';
 interface APIOption {
     stdin: () => string;
     stdout: (str: string) => void;
@@ -17,7 +18,12 @@ interface APIOption {
     path: string;
 }
 interface DebugRunOptions {
+    language?: ClangSourceLanguage;
     args?: string[];
+    compileArgs?: string[];
+    programArgs?: string[];
+    cppVersion?: string;
+    cVersion?: string;
     debug?: boolean;
     breakpoints?: number[];
     pauseOnEntry?: boolean;

package/dist/clang/index.js

@@ -20,7 +20,94 @@ const clangCommonArgs = [
     '80',
     '-fcolor-diagnostics'
 ];
-const clangLanguageStandardArg = '-std=gnu++2a';
+const defaultCppStandardArg = '-std=gnu++2a';
+const defaultCStandardArg = '-std=gnu11';
+function normalizeStandardCode(value) {
+    return (value || '').trim().toUpperCase().replaceAll(/\s+/g, '');
+}
+function resolveCppStandardArg(version) {
+    switch (normalizeStandardCode(version)) {
+        case '03':
+        case 'CPP03':
+        case 'C++03':
+        case 'GNU++03':
+        case 'GNUC++03':
+            return '-std=gnu++03';
+        case '11':
+        case 'CPP11':
+        case 'C++11':
+        case 'GNU++11':
+        case 'GNUC++11':
+            return '-std=gnu++11';
+        case '14':
+        case 'CPP14':
+        case 'C++14':
+        case 'GNU++14':
+        case 'GNUC++14':
+            return '-std=gnu++14';
+        case '17':
+        case 'CPP17':
+        case 'C++17':
+        case 'GNU++17':
+        case 'GNUC++17':
+            return '-std=gnu++17';
+        case '20':
+        case '23':
+        case '26':
+        case 'CPP20':
+        case 'CPP23':
+        case 'CPP26':
+        case 'C++20':
+        case 'C++23':
+        case 'C++26':
+        case 'GNU++20':
+        case 'GNU++23':
+        case 'GNU++26':
+        case 'GNUC++20':
+        case 'GNUC++23':
+        case 'GNUC++26':
+            return defaultCppStandardArg;
+        default:
+            return defaultCppStandardArg;
+    }
+}
+function resolveCStandardArg(version) {
+    switch (normalizeStandardCode(version)) {
+        case '99':
+        case 'C99':
+        case 'GNU99':
+        case 'GNUC99':
+            return '-std=gnu99';
+        case '11':
+        case 'C11':
+        case 'GNU11':
+        case 'GNUC11':
+            return '-std=gnu11';
+        case '17':
+        case '18':
+        case 'C17':
+        case 'C18':
+        case 'GNU17':
+        case 'GNU18':
+        case 'GNUC17':
+        case 'GNUC18':
+            return '-std=gnu17';
+        default:
+            return defaultCStandardArg;
+    }
+}
+function resolveClangLanguageArgs(language, options) {
+    if (language === 'C') {
+        return {
+            languageArg: 'c',
+            standardArg: resolveCStandardArg(options.cVersion)
+        };
+    }
+    return {
+        languageArg: 'c++',
+        standardArg: resolveCppStandardArg(options.cppVersion)
+    };
+}
 const toUtf8 = (text) => {
     const surrogate = encodeURIComponent(text);
     let result = '';
@@ -127,8 +214,11 @@ export default class Clang {
         const input = options.input;
         let source = options.code;
         const obj = options.obj;
+        const language = options.language === 'C' ? 'C' : 'CPP';
+        const compileArgs = options.compileArgs ?? options.args ?? [];
+        const { languageArg, standardArg } = resolveClangLanguageArgs(language, options);
         const debug = !!options.debug;
-        const opt = debug ? '0' : (options.opt || '2');
+        const opt = debug ? '0' : options.opt || '2';
         if (debug) {
             const lines = source.split('\n');
             let braceDepth = 0;
@@ -151,7 +241,7 @@ export default class Clang {
                 '#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);',
@@ -231,7 +321,8 @@ export default class Clang {
                     }
                     else {
                         analysisLine =
-                            analysisLine.slice(0, commentStart) + analysisLine.slice(commentEnd + 2);
+                            analysisLine.slice(0, commentStart) +
+                                analysisLine.slice(commentEnd + 2);
                     }
                 }
                 const lineComment = analysisLine.indexOf('//');
@@ -343,7 +434,9 @@ export default class Clang {
                         let declarationParenDepth = 0;
                         let declarationBraceDepth = 0;
                         for (const character of declarationMatch[2]) {
-                            if (character === ',' && declarationParenDepth === 0 && declarationBraceDepth === 0) {
+                            if (character === ',' &&
+                                declarationParenDepth === 0 &&
+                                declarationBraceDepth === 0) {
                                 if (declarationBuffer.trim())
                                     declarations.push(declarationBuffer.trim());
                                 declarationBuffer = '';
@@ -491,7 +584,8 @@ export default class Clang {
                                 }
                             }
                             for (const [name, variable] of globalVariables) {
-                                if (currentFunctionVariables.has(name) || currentFunctionContainers.has(name))
+                                if (currentFunctionVariables.has(name) ||
+                                    currentFunctionContainers.has(name))
                                     continue;
                                 const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                                 if (new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b`).test(normalized) ||
@@ -529,7 +623,8 @@ export default class Clang {
                                     for (const [name, variable] of currentFunctionVariables) {
                                         const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                                         const mutationPattern = new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b|\\b${escapedName}\\s*(?:[+\\-*/%]?=|\\+\\+|--)`);
-                                        if (!initLooksLikeDeclaration && mutationPattern.test(initSource)) {
+                                        if (!initLooksLikeDeclaration &&
+                                            mutationPattern.test(initSource)) {
                                             initHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
                                         }
                                         if (mutationPattern.test(updateSource)) {
@@ -584,7 +679,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 || '';
@@ -648,9 +743,11 @@ export default class Clang {
                         if (!nameMatch)
                             continue;
                         const name = nameMatch[1];
-                        const kind = /\bbool\b/.test(cleaned) ? 'bool' : /\b(?:int|float|double|char|short|long)\b/.test(cleaned)
-                            ? 'number'
-                            : '';
+                        const kind = /\bbool\b/.test(cleaned)
+                            ? 'bool'
+                            : /\b(?:int|float|double|char|short|long)\b/.test(cleaned)
+                                ? 'number'
+                                : '';
                         if (!kind)
                             continue;
                         const slot = nextVariableSlot++;
@@ -721,11 +818,11 @@ export default class Clang {
             '-O' + opt,
             '-o',
             obj,
-            clangLanguageStandardArg,
+            standardArg,
             '-x',
-            'c++',
+            languageArg,
             input,
-            ...(options.args || [])
+            ...compileArgs
         ];
         this.trace(`compile ${input} -> ${obj}`);
         return await this.run(clang, true, 'clang', ...compilerArgs);
@@ -781,34 +878,53 @@ export default class Clang {
         return stillRunning ? app : null;
     }
     async compileLink(code, options = {}) {
-        const { args = [], debug = false, breakpoints = [], pauseOnEntry = false, debugBuffer, interruptBuffer } = options;
-        const input = `test.cc`, obj = `test.o`, wasm = `test.wasm`;
+        const { language = 'CPP', args = [], compileArgs = args, debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer } = options;
+        const input = language === 'C' ? `test.c` : `test.cc`, obj = `test.o`, wasm = `test.wasm`;
         this.beginTrace(debug);
         this.debugBreakpoints = new Set(debug ? breakpoints : []);
         this.debugPauseOnEntry = debug && pauseOnEntry;
         this.debugBuffer = debugBuffer;
         this.debugInterruptBuffer = interruptBuffer;
-        const buildKey = JSON.stringify({ code, args, debug });
+        const buildKey = JSON.stringify({
+            code,
+            language,
+            compileArgs,
+            cppVersion,
+            cVersion,
+            debug
+        });
         if (this.lastBuildKey === buildKey) {
             this.trace(`reuse ${wasm}`);
             return this.wasm;
         }
-        await this.compile({ input, code, obj, args, debug });
+        await this.compile({
+            input,
+            code,
+            obj,
+            language,
+            compileArgs,
+            cppVersion,
+            cVersion,
+            debug
+        });
         await this.link(obj, wasm, debug);
         this.lastBuildKey = buildKey;
         const wasmBytes = Uint8Array.from(this.memfs.getFileContents(wasm));
         return (this.wasm = await this.hostLogAsync(`Compiling ${wasm}`, WebAssembly.compile(wasmBytes)));
     }
     async compileLinkRun(code, options = {}) {
-        const { args = [], debug = false, breakpoints = [], pauseOnEntry = false, debugBuffer, interruptBuffer } = options;
+        const { language = 'CPP', args = [], compileArgs = args, programArgs = [], debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer } = options;
         this.debug = debug;
         return await this.run(await this.compileLink(code, {
-            args,
+            language,
+            compileArgs,
             debug,
             breakpoints,
             pauseOnEntry,
+            cppVersion,
+            cVersion,
             debugBuffer,
             interruptBuffer
-        }), true, `test.wasm`);
+        }), true, `test.wasm`, ...programArgs);
     }
 }