wasm-idle 0.4.0 → 0.5.0

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 = '';
@@ -50,6 +137,8 @@ export default class Clang {
     debugPauseOnEntry = false;
     debugBuffer;
     debugInterruptBuffer;
+    debugWatchBuffer;
+    debugWatchResultBuffer;
     onDebugEvent;
     debugVariableMetadata = {};
     debugGlobalMetadata = [];
@@ -98,7 +187,7 @@ export default class Clang {
         this.traceStartedAt = Date.now();
     }
     trace(message) {
-        if (!this.debug)
+        if (!this.debug || !this.log)
             return;
         const elapsed = Date.now() - this.traceStartedAt;
         this.stdout(`\x1b[2m[debug +${elapsed}ms] ${message}\x1b[0m\n`);
@@ -127,8 +216,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;
@@ -141,11 +233,98 @@ export default class Clang {
             let currentFunctionContainers = new Map();
             let inBlockComment = false;
             let pendingFunctionHeader;
+            const debugStructTypes = new Map();
+            let structName = '';
+            let structFields = [];
+            let structInBlockComment = false;
+            for (const rawLine of lines) {
+                let structLine = rawLine;
+                if (structInBlockComment) {
+                    const commentEnd = structLine.indexOf('*/');
+                    if (commentEnd === -1)
+                        continue;
+                    structLine = structLine.slice(commentEnd + 2);
+                    structInBlockComment = false;
+                }
+                const commentStart = structLine.indexOf('/*');
+                if (commentStart !== -1) {
+                    const commentEnd = structLine.indexOf('*/', commentStart + 2);
+                    if (commentEnd === -1) {
+                        structInBlockComment = true;
+                        structLine = structLine.slice(0, commentStart);
+                    }
+                    else {
+                        structLine =
+                            structLine.slice(0, commentStart) + structLine.slice(commentEnd + 2);
+                    }
+                }
+                const lineComment = structLine.indexOf('//');
+                if (lineComment !== -1)
+                    structLine = structLine.slice(0, lineComment);
+                const normalizedStructLine = structLine.trim();
+                if (!structName) {
+                    const structMatch = normalizedStructLine.match(/^struct\s+([A-Za-z_]\w*)\s*\{$/);
+                    if (structMatch?.[1]) {
+                        structName = structMatch[1];
+                        structFields = [];
+                    }
+                    continue;
+                }
+                if (normalizedStructLine === '};') {
+                    let structOffset = 0;
+                    let structAlignment = 1;
+                    const resolvedFields = [];
+                    for (const field of structFields) {
+                        const fieldSize = field.kind === 'double'
+                            ? 8
+                            : field.kind === 'bool' || field.kind === 'char'
+                                ? 1
+                                : 4;
+                        if (structOffset % fieldSize !== 0) {
+                            structOffset += fieldSize - (structOffset % fieldSize);
+                        }
+                        resolvedFields.push({
+                            name: field.name,
+                            kind: field.kind,
+                            offset: structOffset
+                        });
+                        structOffset += fieldSize;
+                        structAlignment = Math.max(structAlignment, fieldSize);
+                    }
+                    if (structOffset % structAlignment !== 0) {
+                        structOffset += structAlignment - (structOffset % structAlignment);
+                    }
+                    debugStructTypes.set(structName, {
+                        fields: resolvedFields,
+                        size: Math.max(structOffset, 1)
+                    });
+                    structName = '';
+                    structFields = [];
+                    continue;
+                }
+                const structFieldMatch = normalizedStructLine.match(/^(?:const\s+)?(?:(?:unsigned|signed)\s+)?(?:(?:short|long long|long)\s+)?(int|float|double|bool|char)\s+(.+);$/);
+                if (!structFieldMatch)
+                    continue;
+                for (const declaration of structFieldMatch[2].split(',')) {
+                    const declarator = declaration.split('=')[0]?.trim() || '';
+                    if (!declarator || /[*&\[]/.test(declarator))
+                        continue;
+                    const name = declarator.match(/([A-Za-z_]\w*)\s*$/)?.[1];
+                    if (!name)
+                        continue;
+                    structFields.push({
+                        name,
+                        kind: structFieldMatch[1]
+                    });
+                }
+            }
             this.debugVariableMetadata = {};
             this.debugGlobalMetadata = [];
             this.debugFunctionMetadata = {};
             const globalInitialization = [];
             const instrumented = [
+                '#include <cstdio>',
+                '#include <iostream>',
                 '#include <map>',
                 '#include <set>',
                 '#include <string>',
@@ -231,7 +410,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('//');
@@ -297,6 +477,29 @@ export default class Clang {
                         globalInitialization.push(`${kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(0, ${slot}, ${name});`);
                     }
                 }
+                const globalStructArrayMatch = isTopLevelDeclarationContext &&
+                    normalized.match(/^(?:const\s+)?([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*\[(\d+)\]\s*(?:=.*)?;$/);
+                if (globalStructArrayMatch) {
+                    const structType = debugStructTypes.get(globalStructArrayMatch[1]);
+                    if (structType) {
+                        const slot = nextVariableSlot++;
+                        this.debugGlobalMetadata = [
+                            ...this.debugGlobalMetadata,
+                            {
+                                slot,
+                                name: globalStructArrayMatch[2],
+                                kind: 'array',
+                                length: Number(globalStructArrayMatch[3]),
+                                dimensions: [Number(globalStructArrayMatch[3])],
+                                structFields: structType.fields,
+                                structSize: structType.size,
+                                fromLine: index + 1,
+                                toLine: Number.MAX_SAFE_INTEGER
+                            }
+                        ];
+                        globalInitialization.push(`__wasm_idle_debug_value_addr(0, ${slot}, (int)((unsigned long long)(${globalStructArrayMatch[2]})));`);
+                    }
+                }
                 if (inFunctionBody &&
                     normalized &&
                     !normalized.startsWith('#') &&
@@ -343,7 +546,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 = '';
@@ -429,7 +634,7 @@ export default class Clang {
                                 slot,
                                 kind,
                                 fromLine: index + 1,
-                                toLine: index + 1
+                                toLine: Number.MAX_SAFE_INTEGER
                             });
                             this.debugVariableMetadata[currentFunctionId] = [
                                 ...(this.debugVariableMetadata[currentFunctionId] || []),
@@ -438,7 +643,7 @@ export default class Clang {
                                     name,
                                     kind,
                                     fromLine: index + 1,
-                                    toLine: index + 1
+                                    toLine: Number.MAX_SAFE_INTEGER
                                 }
                             ];
                         }
@@ -458,10 +663,23 @@ export default class Clang {
                                 continue;
                             if (new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b`).test(normalized) ||
                                 new RegExp(`\\b${escapedName}\\s*(?:[+\\-*/%]?=|\\+\\+|--)`).test(normalized) ||
-                                new RegExp(`&\\s*${escapedName}\\b`).test(normalized)) {
+                                new RegExp(`&\\s*${escapedName}\\b`).test(normalized) ||
+                                new RegExp(`\\b(?:cin|std::cin)\\b[^;]*>>\\s*${escapedName}\\b`).test(normalized)) {
                                 trailingInstrumentation.push(`${indent}${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name});`);
                             }
                         }
+                        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) ||
+                                new RegExp(`\\b(?:cin|std::cin)\\b[^;]*>>\\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 (/^return\b/.test(normalized))
                         leadingInstrumentation.push(`${indent}__wasm_idle_debug_leave(${currentFunctionId});`);
@@ -491,7 +709,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) ||
@@ -524,14 +743,20 @@ export default class Clang {
                                     const initSource = segments[0].trim();
                                     const updateSource = segments[2].trim();
                                     const initHooks = [];
+                                    const conditionHooks = [];
                                     const updateHooks = [];
                                     const initLooksLikeDeclaration = /^(?:const\s+)?(?:(?:unsigned|signed)\s+)?(?:(?:short|long long|long)\s+)?(?:int|float|double|bool|char)\b/.test(initSource);
                                     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 (initLooksLikeDeclaration &&
+                                            mutationPattern.test(initSource)) {
+                                            conditionHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
+                                        }
                                         if (mutationPattern.test(updateSource)) {
                                             updateHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
                                         }
@@ -544,7 +769,7 @@ export default class Clang {
                                         : segments[2];
                                     rewrittenLine =
                                         line.slice(0, openIndex + 1) +
-                                            `${instrumentedInit}; (__wasm_idle_debug_line(${currentFunctionId}, ${index + 1}), (${segments[1].trim()})); ${instrumentedUpdate}` +
+                                            `${instrumentedInit}; (${conditionHooks.length ? `${conditionHooks.join(', ')}, ` : ''}__wasm_idle_debug_line(${currentFunctionId}, ${index + 1}), (${segments[1].trim()})); ${instrumentedUpdate}` +
                                             line.slice(closeIndex);
                                 }
                             }
@@ -585,6 +810,12 @@ export default class Clang {
                     currentFunctionVariables = new Map();
                     currentFunctionContainers = new Map();
                     instrumented.push(`${indent}    __wasm_idle_debug_enter(${currentFunctionId}, ${index + 1});`);
+                    if (functionName === 'main') {
+                        instrumented.push(`${indent}    std::cout.setf(std::ios::unitbuf);`);
+                        instrumented.push(`${indent}    std::cerr.setf(std::ios::unitbuf);`);
+                        instrumented.push(`${indent}    setvbuf(stdout, nullptr, _IONBF, 0);`);
+                        instrumented.push(`${indent}    setvbuf(stderr, nullptr, _IONBF, 0);`);
+                    }
                     const parameterSource = startsInlineFunctionBody
                         ? normalized.slice(normalized.indexOf('(') + 1, normalized.lastIndexOf(')'))
                         : pendingFunctionHeader?.parameters || '';
@@ -648,9 +879,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 +954,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);
@@ -750,7 +983,10 @@ export default class Clang {
         app.debugSession = {
             buffer: this.debugBuffer,
             interruptBuffer: this.debugInterruptBuffer,
+            watchBuffer: this.debugWatchBuffer,
+            watchResultBuffer: this.debugWatchResultBuffer,
             breakpoints: new Set(this.debugBreakpoints),
+            breakpointVersion: 0,
             pauseOnEntry: this.debugPauseOnEntry,
             stepArmed: this.debugPauseOnEntry,
             nextLineArmed: false,
@@ -781,34 +1017,57 @@ 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, watchBuffer, watchResultBuffer } = 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 });
+        this.debugWatchBuffer = watchBuffer;
+        this.debugWatchResultBuffer = watchResultBuffer;
+        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, watchBuffer, watchResultBuffer } = 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`);
+            interruptBuffer,
+            watchBuffer,
+            watchResultBuffer
+        }), true, `test.wasm`, ...programArgs);
     }
 }

package/dist/debug/controller.svelte.d.ts

@@ -0,0 +1,43 @@
+import type { DebugLanguageAdapter } from './language';
+import type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable } from '../playground/options';
+import type { TerminalControl } from '../terminal';
+export type DebugWatchValue = {
+    expression: string;
+    value: string;
+};
+export type DebugSessionControllerOptions = {
+    terminal?: TerminalControl;
+    adapter?: DebugLanguageAdapter | null;
+    breakpoints?: number[];
+    cursorLine?: number | null;
+    syncBreakpointsWhile?: boolean | (() => boolean);
+};
+export declare function createDebugSessionController(options?: DebugSessionControllerOptions): {
+    readonly active: boolean;
+    readonly paused: boolean;
+    readonly pausedLine: number | null;
+    readonly locals: DebugVariable[];
+    readonly callStack: DebugFrame[];
+    readonly runToCursorLine: number | null;
+    readonly breakpoints: number[];
+    readonly effectiveBreakpoints: number[];
+    readonly cursorLine: number | null;
+    readonly canRunToCursor: boolean;
+    watchInput: string;
+    readonly watchExpressions: string[];
+    readonly watchValues: DebugWatchValue[];
+    begin: () => void;
+    reset: () => void;
+    handleEvent: (event: DebugSessionEvent) => void;
+    setTerminal: (terminal?: TerminalControl) => void;
+    setAdapter: (adapter: DebugLanguageAdapter | null) => void;
+    setBreakpoints: (lines: number[]) => void;
+    setCursorLine: (line: number | null) => void;
+    sendCommand: (command: DebugCommand) => Promise<boolean>;
+    runToCursor: (targetLine?: number | null) => Promise<boolean>;
+    stop: () => Promise<boolean>;
+    addWatchExpression: (expression?: string) => boolean;
+    removeWatchExpression: (expression: string) => void;
+    clearWatches: () => void;
+};
+export type DebugSessionController = ReturnType<typeof createDebugSessionController>;