Bug: Removed direct calls to FPC Writeln/Write

All VM output now funnels through a single writechar hook
(TIOWriteCharHook) that the OS/emulator layer provides at startup.
High-level helpers (writestring, writeintWND, writehexpair, etc.)
are built entirely on writechar.

- Add src/wasm/vm/wasm.vm.io.pas (hookable IO layer)
- Add src/wasm/test/infra/wasm.test.io.pas (15 assertions)
- Update ~75 files: console -> wasm.vm.io in uses clauses
- Wire emu_writechar (RTL Write wrapper) in WASURO.lpr
- Remove emu/console.pas dependency from all wasm code

.gitignore

@@ -2,3 +2,5 @@
 lib
 AGENTS.md
 GAP_ANALYSIS.md
+*.pdf
+doc/WASI.md

build.ps1

@@ -4,7 +4,8 @@ param(
     [switch]$Clean,
     [switch]$Run,
     [switch]$Help,
-    [switch]$Debug
+    [switch]$Debug,
+    [switch]$E2E
 )
 
 # Also accept positional string args (e.g. .\build.ps1 clean test run)
@@ -15,6 +16,7 @@ foreach ($a in $args) {
         'run'   { $Run   = $true }
         'debug' { $Debug = $true }
         'help'  { $Help  = $true }
+        'e2e'   { $E2E   = $true }
     }
 }
 
@@ -24,6 +26,7 @@ if ($Help) {
     Write-Host '  test   - Build with tests enabled'
     Write-Host '  clean  - Clean build outputs'
     Write-Host '  run    - Run the built executable after building'
+    Write-Host '  e2e    - Run end-to-end wat tests'
     Write-Host '  debug  - Build with debug info and assertions enabled'
     Write-Host '  help   - Show this help message'
     exit 0
@@ -35,11 +38,16 @@ $Bin  = Join-Path $Root 'bin'
 $Lib  = Join-Path $Root 'lib'
 $FPC  = 'C:\Lazarus\fpc\3.2.2\bin\x86_64-win64\fpc.exe'
 
+if (($Test -and $E2E) -or ($Run -and $E2E)) {
+    Write-Host 'Error: --e2e cannot be combined with --test or --run. E2E implies a run of E2E wat tests.' -ForegroundColor Red
+    exit 1
+}
+
 # ── Clean ────────────────────────────────────────────────────────────
 if ($Clean) {
     Write-Host 'Cleaning build outputs...'
-    if (Test-Path $Bin) { Remove-Item $Bin -Recurse -Force }
-    if (Test-Path $Lib) { Remove-Item $Lib -Recurse -Force }
+    if (Test-Path $Bin) { Remove-Item "$Bin\*" -Recurse -Force }
+    if (Test-Path $Lib) { Remove-Item "$Lib\*" -Recurse -Force }
     Write-Host 'Clean complete.'
 }
 
@@ -57,6 +65,7 @@ if ($Debug) { $TestFlags += '-dDEBUG_OUTPUT' }
 
 $fpcArgs = @(
     $TestFlags
+    "-v0ew"
     "-FE$Bin"
     "-FU$Lib"
     "-Fu$Src\emu"
@@ -71,13 +80,14 @@ $fpcArgs = @(
     "-Fu$Src\wasm\types"
     "-Fu$Src\wasm\vm"
     "-Fu$Src\wasm\vm\opcodes"
+    "-Fu$Src\wasm\wasi"
+    "-Fu$Src\wasm\wasi\preview1"
+    "-Fu$Src\wasm\test\wasi"
     '-gw3'
     "-o$Bin\WASURO.exe"
     "$Src\project\WASURO.lpr"
 )
 
-Write-Output $fpcArgs
-
 & $FPC @fpcArgs
 if ($LASTEXITCODE -ne 0) {
     Write-Host "Build failed with error code $LASTEXITCODE"
@@ -91,3 +101,13 @@ if ($Run) {
     Write-Host 'Running WASURO...'
     & "$Bin\WASURO.exe"
 }
+
+if ($E2E) {
+    Write-Host 'Running end-to-end WAT tests...'
+    & (Join-Path $Root 'wat.ps1')
+    if ($LASTEXITCODE -ne 0) {
+        Write-Host "WAT tests failed with error code $LASTEXITCODE"
+        exit $LASTEXITCODE
+    }
+    exit $LASTEXITCODE
+}

src/emu/leb128.pas

@@ -1,66 +0,0 @@
-unit leb128;
-
-interface
-
-uses
-    types;
-
-function read_leb128_to_uint64(buf : puint8; buf_end  : puint8; res  : puint64) : uint8;
-function read_leb128_to_uint32(buf : puint8;  buf_end : puint8; res : puint32)  : uint8;
-
-implementation
-
-function read_leb128_to_uint64(buf: puint8; buf_end: puint8; res: puint64): uint8;
-var
-   ptr : puint8;
-   shift : uint32;
-   localResult : uint64;
-   currentByte : uint8;
-
-begin
-     ptr:= buf;
-     shift:= 0;
-     localResult:= 0;
-     while (true) do begin
-           if (ptr >= buf_end) then begin
-              read_leb128_to_uint64:= 0;
-              exit;
-           end;
-           currentByte:= ptr^;
-           inc(ptr);
-           localResult:= localResult or uint64(currentByte and $7F) SHL Shift;
-           if ((currentByte AND $80) = 0) then break;
-           Inc(Shift, 7);
-     end;
-     res^:= localResult;
-     read_leb128_to_uint64:= uint8(ptr - buf);
-end;
-
-function read_leb128_to_uint32(buf: puint8; buf_end: puint8; res: puint32): uint8;
-var
-   ptr : puint8;
-   shift : uint32;
-   localResult : uint32;
-   currentByte : uint8;
-
-begin
-     ptr:= buf;
-     shift:= 0;
-     localResult:= 0;
-     while (true) do begin
-           if (ptr >= buf_end) then begin
-              read_leb128_to_uint32:= 0;
-              exit;
-           end;
-           currentByte:= ptr^;
-           inc(ptr);
-           localResult:= localResult or uint64(currentByte and $7F) SHL Shift;
-           if ((currentByte AND $80) = 0) then break;
-           Inc(Shift, 7);
-     end;
-     res^:= localResult;
-     read_leb128_to_uint32:= uint8(ptr - buf);
-end;
-
-end.
-

src/emu/types.pas

@@ -36,7 +36,7 @@ type
     sInt8 = shortint;
     sInt16 = smallint;
     sInt32 = integer;
-    sInt64 = longint;
+    sInt64 = int64;
 
     Float = Single;
  

src/emu/wasi.emu.hooks.pas

@@ -0,0 +1,112 @@
+{ Emulator-layer WASI OS hook implementations.
+  This unit provides native hook callbacks for running WASI programs
+  on a host OS (Windows/Linux). On bare-metal (Asuro), these would be
+  replaced by kernel-level implementations.
+
+  Hooks are registered per-context via PWASMProcessContext.
+  This unit has NO knowledge of WASM internals (no stacks, no linear memory). }
+unit wasi.emu.hooks;
+
+interface
+
+uses
+    wasm.types.context;
+
+procedure register_emu_hooks(ctx : PWASMProcessContext);
+
+implementation
+
+uses
+    wasm.types.builtin,
+    wasm.wasi.hooks,
+    wasm.types.wasi;
+
+{ fd_write: write buf to stdout (fd=1) or stderr (fd=2) }
+function emu_fd_write(fd: TWASMUInt32;
+                      buf: TWASMPUInt8;
+                      len: TWASMUInt32): TWASMUInt32;
+var
+    i: TWASMUInt32;
+begin
+    if (fd = 1) or (fd = 2) then begin
+        for i := 0 to len - 1 do
+            Write(TWASMChar(buf[i]));
+        emu_fd_write := len;
+    end else
+        emu_fd_write := 0;
+end;
+
+{ fd_read: stub — no stdin support in emu layer yet }
+function emu_fd_read(fd: TWASMUInt32;
+                     buf: TWASMPUInt8;
+                     len: TWASMUInt32): TWASMUInt32;
+begin
+    emu_fd_read := 0;
+end;
+
+{ fd_close: no-op for emu layer }
+function emu_fd_close(fd: TWASMUInt32): TWASMUInt32;
+begin
+    emu_fd_close := 0; { ESUCCESS }
+end;
+
+{ proc_exit: halt the program with the given exit code }
+procedure emu_proc_exit(code: TWASMUInt32);
+begin
+    { The glue layer already sets Running := false and ExitCode.
+      On the emu layer, we also halt the host process. }
+    halt(code);
+end;
+
+{ clock_time_get: return current time in nanoseconds }
+function emu_clock_time_get(clock_id: TWASMUInt32;
+                            precision: TWASMUInt64;
+                            var time: TWASMUInt64): TWASMUInt32;
+begin
+    { Stub: return 0 nanoseconds. On a real OS we would query the system clock.
+      Bare-metal would use RDTSC or PIT. }
+    time := 0;
+    emu_clock_time_get := WASI_ESUCCESS;
+end;
+
+{ clock_res_get: return clock resolution in nanoseconds }
+function emu_clock_res_get(clock_id: TWASMUInt32;
+                           var resolution: TWASMUInt64): TWASMUInt32;
+begin
+    { Stub: report 1ms resolution }
+    resolution := 1000000;
+    emu_clock_res_get := WASI_ESUCCESS;
+end;
+
+{ random_get: fill buffer with random bytes }
+function emu_random_get(buf: TWASMPUInt8;
+                        len: TWASMUInt32): TWASMUInt32;
+var
+    i: TWASMUInt32;
+    state: TWASMUInt32;
+begin
+    { Simple xorshift PRNG — not cryptographic, but deterministic
+      and works without RTL. On bare-metal, use RDRAND. }
+    state := 2463534242; { seed }
+    for i := 0 to len - 1 do begin
+        state := state xor (state shl 13);
+        state := state xor (state shr 17);
+        state := state xor (state shl 5);
+        buf[i] := TWASMUInt8(state and $FF);
+    end;
+    emu_random_get := WASI_ESUCCESS;
+end;
+
+procedure register_emu_hooks(ctx : PWASMProcessContext);
+begin
+    wasm.wasi.hooks.init_hook_table(ctx);
+    wasm.wasi.hooks.register_fd_write(ctx, @emu_fd_write);
+    wasm.wasi.hooks.register_fd_read(ctx, @emu_fd_read);
+    wasm.wasi.hooks.register_fd_close(ctx, @emu_fd_close);
+    wasm.wasi.hooks.register_proc_exit(ctx, @emu_proc_exit);
+    wasm.wasi.hooks.register_clock_time_get(ctx, @emu_clock_time_get);
+    wasm.wasi.hooks.register_clock_res_get(ctx, @emu_clock_res_get);
+    wasm.wasi.hooks.register_random_get(ctx, @emu_random_get);
+end;
+
+end.

src/project/WASURO.lpr

@@ -2,20 +2,26 @@ program WASURO;
 
 uses
     sysutils,
-
-    console,
-
+    wasm.vm.io,
     wasm.types.builtin,
     wasm.types.context,
-    wasm.types.stack,
-    wasm.parser,
-    wasm.vm
+    wasm,
+
+    { Emu-layer OS hooks }
+    wasi.emu.hooks
+
     {$IFDEF RUN_TESTS}
     , wasm.test
     , wasm.test.framework
     {$ENDIF}
     ;
 
+{ Emu-layer writechar hook — forwards to RTL Write for host OS output }
+procedure emu_writechar(ch : TWASMChar);
+begin
+    Write(ch);
+end;
+
 var
    Context : PWASMProcessContext;
    ModuleSize     : Int64;
@@ -23,16 +29,22 @@ var
    ModuleFile     : File;
 
 begin
+    { Wire up the IO subsystem before anything else }
+    wasm.vm.io.io_set_writechar(@emu_writechar);
+
     {$IFDEF RUN_TESTS}
-    wasm.vm.init();
+    wasm.wasm_init;
     wasm.test.run_all_tests;
     halt(wasm.test.framework.FailedTests);
     {$ELSE}
-    console.writestringln('WASURO - WebAssembly Runtime in Object Pascal');
-    wasm.vm.init();
+    {$IFDEF DEBUG_OUTPUT}
+    wasm.vm.io.writestringln('WASURO - WebAssembly Runtime in Object Pascal');
+    {$ENDIF}
+    wasm.wasm_init;
+
     if ParamCount > 0 then begin
         if not FileExists(ParamStr(1)) then begin
-            console.writestringln('File not found.');
+            wasm.vm.io.writestringln('File not found.');
             halt(1);
         end;
         Assign(ModuleFile, ParamStr(1));
@@ -41,30 +53,37 @@ begin
         GetMem(ModuleBuffer, ModuleSize);
         BlockRead(ModuleFile, ModuleBuffer^, ModuleSize);
         Close(ModuleFile);
-        console.writestringln('Module loaded.');
-        Context := wasm.parser.parse(ModuleBuffer, TWASMPUInt8(ModuleBuffer + ModuleSize));
-        while wasm.vm.tick(Context) do ;
-        console.writestringln('Execution finished.');
-        console.writestringln('');
-        console.writestringln('--- VM State ---');
-        writeln('IP:      ', Context^.ExecutionState.IP);
-        writeln('Running: ', Context^.ExecutionState.Running);
-        writeln('');
-        writeln('Operand Stack (', Context^.ExecutionState.Operand_Stack^.Top, ' entries):');
-        if Context^.ExecutionState.Operand_Stack^.Top > 0 then
-            wasm.types.stack.walk(Context^.ExecutionState.Operand_Stack)
-        else
-            console.writestringln('  (empty)');
-        writeln('');
-        writeln('Control Stack (', Context^.ExecutionState.Control_Stack^.Top, ' entries):');
-        if Context^.ExecutionState.Control_Stack^.Top > 0 then
-            wasm.types.stack.walk(Context^.ExecutionState.Control_Stack)
-        else
-            console.writestringln('  (empty)');
-        console.writestringln('----------------');
+        {$IFDEF DEBUG_OUTPUT}
+         write('Module loaded from file: ');
+         writeln(ParamStr(1));
+        {$ENDIF}
+
+        { Load, configure, and run the WASM module }
+        Context := wasm.wasm_load(ModuleBuffer, TWASMPUInt8(ModuleBuffer + ModuleSize));
+
+        if not Context^.ValidBinary then begin
+            wasm.vm.io.writestringln('Error: Invalid WASM binary.');
+            halt(1);
+        end;
+
+        { Register emu-layer OS hooks and WASI preview1 into context }
+        wasi.emu.hooks.register_emu_hooks(Context);
+        wasm.wasm_register_wasi_preview1(Context);
+
+        { Find _start and run to completion }
+        if not wasm.wasm_start(Context) then begin
+            wasm.vm.io.writestringln('No _start export found.');
+            halt(1);
+        end;
+
+        {$IFDEF DEBUG_OUTPUT}
+        wasm.wasm_dump_state(Context);
+        {$ENDIF}
+
         FreeMem(ModuleBuffer);
+        halt(Context^.ExitCode);
     end else begin
-        console.writestringln('Usage: WASURO <module.wasm>');
+        wasm.vm.io.writestringln('Usage: WASURO <module.wasm>');
         halt(1);
     end;
     {$ENDIF}

src/wasm/parser/sections/wasm.parser.sections.codeSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.codeSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.enums, wasm.types.values, wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -73,8 +73,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Code - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Code - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     // Initialize the read/end pointers

src/wasm/parser/sections/wasm.parser.sections.customSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.customSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -13,11 +13,11 @@ implementation
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Custom - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Custom - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
     { Custom sections are ignored in this implementation }
-    console.writestringln('[wasm.parser] TODO: Custom section skipped.');
+    wasm.vm.io.writestringln('[wasm.parser] TODO: Custom section skipped.');
 end;
 
 end.

src/wasm/parser/sections/wasm.parser.sections.dataCountSection.pas

@@ -9,7 +9,7 @@ procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMPro
 
 implementation
 
-uses console, leb128, lmemorymanager, wasm.types.sections;
+uses wasm.vm.io, wasm.types.leb128, lmemorymanager, wasm.types.sections;
 
 { DataCount section (ID 12): contains a single u32 count of data segments.
   Pre-allocates the DataSegments array so that bulk memory opcodes
@@ -21,8 +21,8 @@ var
     dataCount : TWASMUInt32;
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: DataCount - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: DataCount - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     pos := buffer;

src/wasm/parser/sections/wasm.parser.sections.dataSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.dataSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.sections, wasm.types.context, wasm.types.heap;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -26,8 +26,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Data - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Data - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     pos := buffer;

src/wasm/parser/sections/wasm.parser.sections.elementSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.elementSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -24,8 +24,8 @@ var
     indices: TWASMPUInt32;
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Element - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Element - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     pos := buffer;

src/wasm/parser/sections/wasm.parser.sections.exportSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.exportSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.enums, wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -37,8 +37,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Export - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Export - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     // Initialize the read/end pointers

src/wasm/parser/sections/wasm.parser.sections.functionSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.functionSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -33,8 +33,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Function - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Function - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     // Initialize the read/end pointers

src/wasm/parser/sections/wasm.parser.sections.globalSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.globalSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.enums, wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -50,8 +50,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Global - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Global - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
     
     pos := buffer;

src/wasm/parser/sections/wasm.parser.sections.importSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.importSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.enums, wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -72,8 +72,8 @@ var
    limitsFlag : TWASMUInt8;
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Import - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Import - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     pos := buffer;

src/wasm/parser/sections/wasm.parser.sections.memorySection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.memorySection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.sections, wasm.types.context, wasm.types.heap;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -40,8 +40,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Memory - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Memory - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     pos := buffer;

src/wasm/parser/sections/wasm.parser.sections.startSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.startSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -17,8 +17,8 @@ var
 
 begin
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser] Handle Section: Start - Size: ');
-     console.writeintlnWND(section_length, 0);
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Start - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     { Read the start function index }
@@ -26,8 +26,8 @@ begin
     ctx^.Sections.StartIndex := TWASMInt32(funcIdx);
 
     {$IFDEF DEBUG_OUTPUT}
-     console.writestring('[wasm.parser]     Start Function Index: ');
-     console.writeintlnWND(funcIdx, 0);
+     wasm.vm.io.writestring('[wasm.parser]     Start Function Index: ');
+     wasm.vm.io.writeintlnWND(funcIdx, 0);
     {$ENDIF}
 end;
 

src/wasm/parser/sections/wasm.parser.sections.tableSection.pas

@@ -3,7 +3,7 @@ unit wasm.parser.sections.tableSection;
 interface
 
 uses
-    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
     wasm.types.sections, wasm.types.context;
 
 procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
@@ -20,8 +20,8 @@ var
     tables: PWASMTables;
 begin
     {$IFDEF DEBUG_OUTPUT}
-    console.writestring('[wasm.parser] Handle Section: Table - Size: ');
-    console.writeintlnWND(section_length, 0);
+    wasm.vm.io.writestring('[wasm.parser] Handle Section: Table - Size: ');
+    wasm.vm.io.writeintlnWND(section_length, 0);
     {$ENDIF}
 
     pos := buffer;
@@ -60,17 +60,17 @@ begin
         end;
 
         {$IFDEF DEBUG_OUTPUT}
-        console.writestring('[wasm.parser]     Table ');
-        console.writeintWND(i, 0);
-        console.writestring(' - ElemType: $');
-        console.writeintWND(elem_type, 0);
-        console.writestring(' Initial: ');
-        console.writeintWND(min_size, 0);
+        wasm.vm.io.writestring('[wasm.parser]     Table ');
+        wasm.vm.io.writeintWND(i, 0);
+        wasm.vm.io.writestring(' - ElemType: $');
+        wasm.vm.io.writeintWND(elem_type, 0);
+        wasm.vm.io.writestring(' Initial: ');
+        wasm.vm.io.writeintWND(min_size, 0);
         if limits_flag = 1 then begin
-            console.writestring(' Max: ');
-            console.writeintWND(max_size, 0);
+            wasm.vm.io.writestring(' Max: ');
+            wasm.vm.io.writeintWND(max_size, 0);
         end;
-        console.writestringln('');
+        wasm.vm.io.writestringln('');
         {$ENDIF}
 
         tables^.Tables[i].ElementType := elem_type;