Merge pull request 'Bug: Removed direct calls to FPC Writeln/Write' (#2) from feature/compatability into develop

Reviewed-on: #2

.gitignore

@@ -1,3 +1,6 @@
 bin
 lib
 AGENTS.md
+GAP_ANALYSIS.md
+*.pdf
+doc/WASI.md

build.bat

@@ -1,39 +0,0 @@
-@echo off
-setlocal
-
-set ROOT=%~dp0
-set SRC=%ROOT%src
-set BIN=%ROOT%bin
-set LIB=%ROOT%lib
-set FPC=C:\Lazarus\fpc\3.2.2\bin\x86_64-win64\fpc.exe
-
-set TESTFLAGS=
-if "%1"=="test" set TESTFLAGS=-dRUN_TESTS
-
-if not exist "%BIN%" mkdir "%BIN%"
-if not exist "%LIB%" mkdir "%LIB%"
-
-"%FPC%" ^
-  %TESTFLAGS% ^
-  -FE"%BIN%" ^
-  -FU"%LIB%" ^
-  -Fu"%SRC%\emu" ^
-  -Fu"%SRC%\wasm" ^
-  -Fu"%SRC%\wasm\parser" ^
-  -Fu"%SRC%\wasm\parser\sections" ^
-  -Fu"%SRC%\wasm\test" ^
-  -Fu"%SRC%\wasm\test\opcodes" ^
-  -Fu"%SRC%\wasm\test\parsers" ^
-  -Fu"%SRC%\wasm\test\infra" ^
-  -Fu"%SRC%\wasm\types" ^
-  -Fu"%SRC%\wasm\vm" ^
-  -gw3 ^
-  -o"%BIN%\WASURO.exe" ^
-  "%SRC%\project\WASURO.lpr"
-
-if %ERRORLEVEL% NEQ 0 (
-    echo Build failed with error code %ERRORLEVEL%
-    exit /b %ERRORLEVEL%
-)
-
-echo Build succeeded: %BIN%\WASURO.exe

build.ps1

@@ -0,0 +1,113 @@
+# build.ps1 — Build script for the WASURO project
+param(
+    [switch]$Test,
+    [switch]$Clean,
+    [switch]$Run,
+    [switch]$Help,
+    [switch]$Debug,
+    [switch]$E2E
+)
+
+# Also accept positional string args (e.g. .\build.ps1 clean test run)
+foreach ($a in $args) {
+    switch ($a.ToLower()) {
+        'test'  { $Test  = $true }
+        'clean' { $Clean = $true }
+        'run'   { $Run   = $true }
+        'debug' { $Debug = $true }
+        'help'  { $Help  = $true }
+        'e2e'   { $E2E   = $true }
+    }
+}
+
+if ($Help) {
+    Write-Host 'Usage: .\build.ps1 [options]'
+    Write-Host 'Options:'
+    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
+}
+
+$Root = $PSScriptRoot
+$Src  = Join-Path $Root 'src'
+$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 }
+    Write-Host 'Clean complete.'
+}
+
+if (-not (Test-Path $Bin)) { New-Item $Bin -ItemType Directory | Out-Null }
+if (-not (Test-Path $Lib)) { New-Item $Lib -ItemType Directory | Out-Null }
+
+# ── Lint ─────────────────────────────────────────────────────────────
+& (Join-Path $Root 'lint.ps1') -SrcRoot $Src
+if ($LASTEXITCODE -ne 0) { exit 1 }
+
+# ── Build ────────────────────────────────────────────────────────────
+$TestFlags = @()
+if ($Test)  { $TestFlags += '-dRUN_TESTS' }
+if ($Debug) { $TestFlags += '-dDEBUG_OUTPUT' }
+
+$fpcArgs = @(
+    $TestFlags
+    "-v0ew"
+    "-FE$Bin"
+    "-FU$Lib"
+    "-Fu$Src\emu"
+    "-Fu$Src\wasm"
+    "-Fu$Src\wasm\parser"
+    "-Fu$Src\wasm\parser\sections"
+    "-Fu$Src\wasm\test"
+    "-Fu$Src\wasm\test\opcodes"
+    "-Fu$Src\wasm\test\parsers"
+    "-Fu$Src\wasm\test\binaries"
+    "-Fu$Src\wasm\test\infra"
+    "-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"
+)
+
+& $FPC @fpcArgs
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "Build failed with error code $LASTEXITCODE"
+    exit $LASTEXITCODE
+}
+
+Write-Host "Build succeeded: $Bin\WASURO.exe"
+
+# ── Run ──────────────────────────────────────────────────────────────
+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
+}

lint.ps1

@@ -0,0 +1,48 @@
+# lint.ps1 — Static lint rules for the WASURO project
+# Called by build.ps1 before compilation. Exit 1 on any violation.
+param(
+    [string]$SrcRoot = (Join-Path $PSScriptRoot 'src')
+)
+
+$fail = $false
+
+# ── Rule: No native types in src\wasm ────────────────────────────────
+# All code under src\wasm must use TWASM* aliases from wasm.types.builtin.
+# Only wasm.types.builtin.pas itself may reference the raw types.
+$forbiddenTypes = @(
+    'uint8','uint16','uint32','uint64',
+    'sint8','sint16',
+    'int32','int64',
+    'float','double',
+    'puint8','puint16','puint32','puint64',
+    'pfloat','pdouble','pchar',
+    'boolean','char','void','integer'
+)
+$pattern = '(?i)(?<![a-z0-9_])(' + ($forbiddenTypes -join '|') + ')(?![a-z0-9_])'
+
+$files = Get-ChildItem (Join-Path $SrcRoot 'wasm') -Recurse -Filter '*.pas' |
+    Where-Object { $_.Name -ne 'wasm.types.builtin.pas' }
+
+$ruleHits = 0
+foreach ($file in $files) {
+    $content = [IO.File]::ReadAllText($file.FullName)
+    $matches = [regex]::Matches($content, $pattern)
+    if ($matches.Count -gt 0) {
+        $found = @{}
+        foreach ($m in $matches) { $found[$m.Value.ToLower()] = $true }
+        $list = ($found.Keys | Sort-Object) -join ', '
+        Write-Host "  $($file.Name): $list"
+        $ruleHits++
+    }
+}
+
+if ($ruleHits -gt 0) {
+    Write-Host ''
+    Write-Host "Lint failed: $ruleHits file(s) use native types. Use TWASM* from wasm.types.builtin instead."
+    $fail = $true
+}
+
+# ── Add more rules here ─────────────────────────────────────────────
+if ($fail) { exit 1 }
+Write-Host 'Lint passed.'
+exit 0

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,46 +2,90 @@ program WASURO;
 
 uses
     sysutils,
+    wasm.vm.io,
+    wasm.types.builtin,
+    wasm.types.context,
+    wasm,
 
-    console,
+    { Emu-layer OS hooks }
+    wasi.emu.hooks
 
-    types,
-
-    wasm.types,
-    wasm.parser,
-    wasm.vm, wasm.test.binary,
-    wasm.types.stack
     {$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;
+   ModuleBuffer   : TWASMPUInt8;
+   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}
-    writestringln('[main] Initializing VM');
-    wasm.vm.init();
+    {$IFDEF DEBUG_OUTPUT}
+    wasm.vm.io.writestringln('WASURO - WebAssembly Runtime in Object Pascal');
+    {$ENDIF}
+    wasm.wasm_init;
 
-    writestringln('[main] Parsing WASM Binary');
-    Context:= wasm.parser.parse(@wasm.test.binary.TEST_BINARY_1[0], puint8(@wasm.test.binary.TEST_BINARY_1[0] + $26));
+    if ParamCount > 0 then begin
+        if not FileExists(ParamStr(1)) then begin
+            wasm.vm.io.writestringln('File not found.');
+            halt(1);
+        end;
+        Assign(ModuleFile, ParamStr(1));
+        Reset(ModuleFile, 1);
+        ModuleSize := FileSize(ModuleFile);
+        GetMem(ModuleBuffer, ModuleSize);
+        BlockRead(ModuleFile, ModuleBuffer^, ModuleSize);
+        Close(ModuleFile);
+        {$IFDEF DEBUG_OUTPUT}
+         write('Module loaded from file: ');
+         writeln(ParamStr(1));
+        {$ENDIF}
 
-    writestringln('[main] Running...');
-    Context^.ExecutionState.Running:= true;
-    while (wasm.vm.tick(Context)) do;
-    writestringln('[main] Finished Execution');
-    writestring('[main] Returns: ');
-    while Context^.ExecutionState.Operand_Stack^.Top > 0 do begin
-        write(wasm.types.stack.popi32(Context^.ExecutionState.Operand_Stack),', ');
+        { 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
+        wasm.vm.io.writestringln('Usage: WASURO <module.wasm>');
+        halt(1);
     end;
-    writeln();
-    while true do sleep(1000);
     {$ENDIF}
 end.
 

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

@@ -3,16 +3,16 @@ unit wasm.parser.sections.codeSection;
 interface
 
 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    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: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 
 implementation
 
 procedure printCtxCode(ctx : PWASMProcessContext);
 var
-    i : uint32;
+    i : TWASMUInt32;
 
 begin
     writestring('[wasm.parser]     Flat Code: ');
@@ -25,15 +25,15 @@ end;
 
 procedure walk(ctx : PWASMProcessContext);
 var
-   localpos, pos, bend : puint8;
-   bytesRead : uint8;
+   localpos, pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
    currentEntry : PWASMCodeEntry;
-   i,j,l : uint32;
-   localCount,localTemp,localIndex : uint32;
+   i,j,l : TWASMUInt32;
+   localCount,localTemp,localIndex : TWASMUInt32;
    localType: TWasmValueType;
-   codeLength: uint32;
-   codeOffset: uint32;
-   totalSize: uint32;
+   codeLength: TWASMUInt32;
+   codeOffset: TWASMUInt32;
+   totalSize: TWASMUInt32;
 begin
     // Walk the code entries
     for i:=1 to ctx^.Sections.CodeSection^.CodeCount do begin
@@ -59,25 +59,27 @@ begin
 end;
 
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   localpos, pos, bend : puint8;
-   bytesRead : uint8;
+   localpos, pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
    currentEntry : PWASMCodeEntry;
-   i,j,l : uint32;
-   localCount,localTemp,localIndex : uint32;
+   i,j,l : TWASMUInt32;
+   localCount,localTemp,localIndex : TWASMUInt32;
    localType: TWasmValueType;
-   codeLength: uint32;
-   codeOffset: uint32;
-   totalSize: uint32;
+   codeLength: TWASMUInt32;
+   codeOffset: TWASMUInt32;
+   totalSize: TWASMUInt32;
 
 begin
-    writestring('[wasm.parser] Handle Section: Code - Size: ');
-    writeintlnWND(section_length, 0);
+    {$IFDEF DEBUG_OUTPUT}
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Code - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
+    {$ENDIF}
 
     // Initialize the read/end pointers
     pos:= buffer;
-    bend:= puint8(pos + section_length);
+    bend:= TWASMPUInt8(pos + section_length);
 
     // Initialize the code section
     ctx^.Sections.CodeSection:= PWASMCodeSection(kalloc(sizeof(TWASMCodeSection)));
@@ -158,7 +160,7 @@ begin
             end;
 
             // Read the code
-            currentEntry^.Code:= puint8(kalloc(currentEntry^.CodeLength));
+            currentEntry^.Code:= TWASMPUInt8(kalloc(currentEntry^.CodeLength));
             for j:=1 to currentEntry^.CodeLength do begin
                 currentEntry^.Code[j - 1]:= pos^;
                 inc(pos);
@@ -171,20 +173,21 @@ begin
             totalSize:= totalSize + currentEntry^.CodeLength;
         end;
 
-        ctx^.ExecutionState.Code:= puint8(kalloc(totalSize));
+        ctx^.ExecutionState.Code:= TWASMPUInt8(kalloc(totalSize));
         ctx^.ExecutionState.Limit:= totalSize;
         localpos:= ctx^.ExecutionState.Code;
         for i:=1 to ctx^.Sections.CodeSection^.CodeCount do begin
             currentEntry:= @ctx^.Sections.CodeSection^.Entries[i - 1];
-            currentEntry^.CodeIndex:= uint32(localpos - ctx^.ExecutionState.Code);
+            currentEntry^.CodeIndex:= TWASMUInt32(localpos - ctx^.ExecutionState.Code);
             for j:=1 to currentEntry^.CodeLength do begin
                 localpos^:= currentEntry^.Code[j - 1];
                 inc(localpos);
             end;
         end;
     end;
-
+    {$IFDEF DEBUG_OUTPUT}
     walk(ctx);
+    {$ENDIF}
 end;
 
 end.

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

@@ -3,17 +3,21 @@ unit wasm.parser.sections.customSection;
 interface
 
 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
+    wasm.types.context;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 
 implementation
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 begin
-    writestring('[wasm.parser] Handle Section: Custom - Size: ');
-    writeintlnWND(section_length, 0);
+    {$IFDEF DEBUG_OUTPUT}
+     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 }
+    wasm.vm.io.writestringln('[wasm.parser] TODO: Custom section skipped.');
 end;
 
 end.

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

@@ -0,0 +1,48 @@
+unit wasm.parser.sections.dataCountSection;
+
+interface
+
+uses
+    wasm.types.builtin, wasm.types.context;
+
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
+
+implementation
+
+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
+  can reference segments by index during validation. }
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
+var
+    pos, bend : TWASMPUInt8;
+    bytesRead : TWASMUInt8;
+    dataCount : TWASMUInt32;
+begin
+    {$IFDEF DEBUG_OUTPUT}
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: DataCount - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
+    {$ENDIF}
+
+    pos := buffer;
+    bend := TWASMPUInt8(buffer + section_length);
+
+    bytesRead := read_leb128_to_uint32(pos, bend, @dataCount);
+    Inc(pos, bytesRead);
+
+    {$IFDEF DEBUG_OUTPUT}
+    writestring('[wasm.parser]     Data Count: ');
+    writeintlnWND(dataCount, 0);
+    {$ENDIF}
+
+    { Pre-allocate data segment storage with correct count.
+      The actual segment data will be filled when the Data section is parsed. }
+    ctx^.ExecutionState.DataSegments^.SegmentCount := dataCount;
+    if dataCount > 0 then
+        ctx^.ExecutionState.DataSegments^.Segments := PWASMDataSegment(kalloc(dataCount * sizeof(TWASMDataSegment)))
+    else
+        ctx^.ExecutionState.DataSegments^.Segments := nil;
+end;
+
+end.

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

@@ -3,17 +3,17 @@ unit wasm.parser.sections.exportSection;
 interface
 
 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
+    wasm.types.enums, wasm.types.sections, wasm.types.context;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 
 implementation
 
 procedure walk(ctx : PWASMProcessContext);
 var
    currentEntry : PWASMExportEntry;
-   i : uint32;
+   i : TWASMUInt32;
 
 begin
     // Walk the export entries
@@ -28,20 +28,22 @@ begin
     end;
 end;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   pos, bend : puint8;
-   bytesRead : uint8;
+   pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
    currentEntry : PWASMExportEntry;
-   i,j : uint32;
+   i,j : TWASMUInt32;
 
 begin
-    writestring('[wasm.parser] Handle Section: Export - Size: ');
-    writeintlnWND(section_length, 0);
+    {$IFDEF DEBUG_OUTPUT}
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Export - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
+    {$ENDIF}
 
     // Initialize the read/end pointers
     pos:= buffer;
-    bend:= puint8(pos + section_length);
+    bend:= TWASMPUInt8(pos + section_length);
 
     // Initialize the export section
     ctx^.Sections.ExportSection:= PWASMExportSection(kalloc(sizeof(TWASMExportSection)));
@@ -69,12 +71,12 @@ begin
             inc(pos, bytesRead);
 
             // Read the export name
-            currentEntry^.Name:= pchar(kalloc(currentEntry^.NameLength + 1));
+            currentEntry^.Name:= TWASMPChar(kalloc(currentEntry^.NameLength + 1));
             for j:=0 to currentEntry^.NameLength - 1 do begin
-                currentEntry^.Name[j]:= char(pos^);
+                currentEntry^.Name[j]:= TWASMChar(pos^);
                 inc(pos);
             end;
-            currentEntry^.Name[currentEntry^.NameLength]:= char($00);
+            currentEntry^.Name[currentEntry^.NameLength]:= TWASMChar($00);
 
             // Read the export type
             currentEntry^.ExportType:= TWasmExportType(pos^);
@@ -85,8 +87,9 @@ begin
             inc(pos, bytesRead);
         end;
     end;
-
+    {$IFDEF DEBUG_OUTPUT}
     walk(ctx);
+    {$ENDIF}
 end;
 
 end.

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

@@ -3,17 +3,17 @@ unit wasm.parser.sections.functionSection;
 interface
 
 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
+    wasm.types.sections, wasm.types.context;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 
 implementation
 
 procedure walk(ctx : PWASMProcessContext);
 var
    currentFunc : PWASMFunction;
-   i : uint32;
+   i : TWASMUInt32;
 
 begin
     // Walk the functions
@@ -24,20 +24,22 @@ begin
     end;
 end;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   pos, bend : puint8;
-   bytesRead : uint8;
+   pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
    currentFunc : PWASMFunction;
-   i : uint32;
+   i : TWASMUInt32;
 
 begin
-    writestring('[wasm.parser] Handle Section: Function - Size: ');
-    writeintlnWND(section_length, 0);
+    {$IFDEF DEBUG_OUTPUT}
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Function - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
+    {$ENDIF}
 
     // Initialize the read/end pointers
     pos:= buffer;
-    bend:= puint8(pos + section_length);
+    bend:= TWASMPUInt8(pos + section_length);
 
     // Initialize the function section
     ctx^.Sections.FunctionSection:= PWASMFunctionSection(kalloc(sizeof(TWASMFunctionSection)));
@@ -64,8 +66,9 @@ begin
             inc(pos, bytesRead);
         end;
     end;
-    
+    {$IFDEF DEBUG_OUTPUT}
     walk(ctx);
+    {$ENDIF}
 end;
 
 end.

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

@@ -3,16 +3,16 @@ unit wasm.parser.sections.globalSection;
 interface
 
 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
+    wasm.types.enums, wasm.types.sections, wasm.types.context;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 
 implementation
 
 procedure walk(ctx : PWASMProcessContext);
 var
-   i : uint32;
+   i : TWASMUInt32;
    entry : PWASMGlobalEntry;
 begin
     for i := 0 to ctx^.ExecutionState.Globals^.GlobalCount - 1 do begin
@@ -35,25 +35,27 @@ begin
     end;
 end;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   pos, bend : puint8;
-   bytesRead : uint8;
-   globalCount : uint32;
-   i : uint32;
+   pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
+   globalCount : TWASMUInt32;
+   i : TWASMUInt32;
    entry : PWASMGlobalEntry;
-   valType : uint8;
-   mutFlag : uint8;
-   opcode : uint8;
-   tmpU32 : uint32;
-   tmpU64 : uint64;
+   valType : TWASMUInt8;
+   mutFlag : TWASMUInt8;
+   opcode : TWASMUInt8;
+   tmpU32 : TWASMUInt32;
+   tmpU64 : TWASMUInt64;
 
 begin
-    writestring('[wasm.parser] Handle Section: Global - Size: ');
-    writeintlnWND(section_length, 0);
-
+    {$IFDEF DEBUG_OUTPUT}
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Global - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
+    {$ENDIF}
+    
     pos := buffer;
-    bend := puint8(buffer + section_length);
+    bend := TWASMPUInt8(buffer + section_length);
 
     { Read global count }
     bytesRead := read_leb128_to_uint32(pos, bend, @globalCount);
@@ -88,19 +90,19 @@ begin
             $41: begin { i32.const }
                 bytesRead := read_leb128_to_uint32(pos, bend, @tmpU32);
                 Inc(pos, bytesRead);
-                entry^.Value.i32Value := int32(tmpU32);
+                entry^.Value.i32Value := TWASMInt32(tmpU32);
             end;
             $42: begin { i64.const }
                 bytesRead := read_leb128_to_uint64(pos, bend, @tmpU64);
                 Inc(pos, bytesRead);
-                entry^.Value.i64Value := int64(tmpU64);
+                entry^.Value.i64Value := TWASMInt64(tmpU64);
             end;
             $43: begin { f32.const }
-                entry^.Value.f32Value := pfloat(pos)^;
+                entry^.Value.f32Value := TWASMPFloat(pos)^;
                 Inc(pos, 4);
             end;
             $44: begin { f64.const }
-                entry^.Value.f64Value := pdouble(pos)^;
+                entry^.Value.f64Value := TWASMPDouble(pos)^;
                 Inc(pos, 8);
             end;
         else
@@ -115,8 +117,9 @@ begin
         if (pos < bend) and (pos^ = $0B) then
             Inc(pos);
     end;
-
+    {$IFDEF DEBUG_OUTPUT}
     walk(ctx);
+    {$ENDIF}
 end;
 
 end.

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

@@ -3,16 +3,16 @@ unit wasm.parser.sections.memorySection;
 interface
 
 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types, wasm.types.heap;
+    wasm.types.builtin, lmemorymanager, wasm.vm.io, wasm.types.leb128,
+    wasm.types.sections, wasm.types.context, wasm.types.heap;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 
 implementation
 
 procedure walk(ctx : PWASMProcessContext);
 var
-   i : uint32;
+   i : TWASMUInt32;
    mem : PWASMMemoryLimits;
 begin
     for i := 0 to ctx^.Sections.MemorySection^.MemoryCount - 1 do begin
@@ -29,21 +29,23 @@ begin
     end;
 end;
 
-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   pos, bend : puint8;
-   bytesRead : uint8;
-   memCount : uint32;
-   i : uint32;
+   pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
+   memCount : TWASMUInt32;
+   i : TWASMUInt32;
    mem : PWASMMemoryLimits;
-   flags : uint32;
+   flags : TWASMUInt32;
 
 begin
-    writestring('[wasm.parser] Handle Section: Memory - Size: ');
-    writeintlnWND(section_length, 0);
+    {$IFDEF DEBUG_OUTPUT}
+     wasm.vm.io.writestring('[wasm.parser] Handle Section: Memory - Size: ');
+     wasm.vm.io.writeintlnWND(section_length, 0);
+    {$ENDIF}
 
     pos := buffer;
-    bend := puint8(buffer + section_length);
+    bend := TWASMPUInt8(buffer + section_length);
 
     { Read memory count }
     bytesRead := read_leb128_to_uint32(pos, bend, @memCount);
@@ -77,8 +79,9 @@ begin
         while ctx^.ExecutionState.Memory^.PageCount < mem^.InitialPages do
             wasm.types.heap.expand_heap(ctx^.ExecutionState.Memory);
     end;
-
+    {$IFDEF DEBUG_OUTPUT}
     walk(ctx);
+    {$ENDIF}
 end;
 
 end.