refactor: build.bat flexible argument parsing, add run & help commands

- Replaced positional `%1` checks with a loop-based argument parser so flags (`test`, `clean`, `run`, `help`) work in any order/combination - Added `run` flag: executes `bin\WASURO.exe` after a successful build - Added `help` flag: prints usage info and exits - Fixed `clean` early-exit to also check `DO_RUN` (not just `TESTFLAGS`), so `build.bat clean run` correctly continues to build+run - Added section comment headers (Build, Run) for consistency
Merge branch 'feature/missing-opcodes' into develop
2026-02-24 14:57:30 +00:00 · 2026-02-24 14:47:01 +00:00 · 2026-02-24 14:46:30 +00:00 · 2026-02-24 13:24:15 +00:00 · 2026-02-24 13:23:46 +00:00 · 2026-02-24 13:05:42 +00:00
168 changed files with 8498 additions and 795 deletions
@@ -1,2 +1,3 @@
 bin
 lib
+AGENTS.md
@@ -0,0 +1,89 @@
+# WASURO
+
+A WebAssembly virtual machine for the [Asuro](https://gitea.spexeah.com/Spexeah/Asuro) operating system, written in Standard Pascal.
+
+WASURO parses and executes WASM binaries directly in a bare-metal kernel environment — no runtime library, no classes, no heap manager beyond what the OS provides.
+
+## Architecture
+
+```
+src/
+├── emu/               # OS emulation layer (types, console, memory, LEB128)
+├── wasm/              # WASM Virtual Machine
+│   ├── parser/        # WASM binary parser
+│   │   └── sections/  # Section-specific parsers (type, function, export,
+│   │                  #   code, global, memory, start, data, etc.)
+│   ├── types/         # WASM type system, stack, and linear memory (heap)
+│   ├── vm/            # VM tick loop and opcode jump table
+│   └── test/          # Test suite
+│       ├── infra/     # Stack, heap, LEB128 tests
+│       ├── opcodes/   # Per-opcode test units
+│       └── parsers/   # Per-section parser tests
+└── project/           # Lazarus project files
+```
+
+### Key components
+
+- **VM** (`wasm.vm`) — Tick-based execution loop dispatching opcodes through a 256-entry jump table.
+- **Parser** (`wasm.parser`) — Validates the WASM magic/version header, then routes each binary section to its handler.
+- **Stack** (`wasm.types.stack`) — Operand and control stacks supporting i32, i64, f32, f64 push/pop.
+- **Heap** (`wasm.types.heap`) — Paged linear memory with read/write at 8/16/32/64-bit widths.
+- **Emulation layer** (`src/emu/`) — Provides the same `types`, `console`, `lmemorymanager`, and `leb128` interfaces that exist in the real Asuro kernel, allowing development and testing on a host OS.
+
+### Implemented opcodes
+
+| Category | Opcodes |
+|---|---|
+| Control | `nop`, `unreachable`, `drop`, `select`, `return` |
+| Variables | `local.get/set/tee`, `global.get/set` |
+| Constants | `i32.const`, `i64.const`, `f32.const`, `f64.const` |
+| i32 Arithmetic | `add`, `sub`, `mul`, `div_s/u`, `rem_s/u`, `clz`, `ctz`, `popcnt` |
+| i32 Bitwise | `and`, `or`, `xor`, `shl`, `shr_s/u`, `rotl`, `rotr` |
+| i32 Comparison | `eqz`, `eq`, `ne`, `lt_s/u`, `gt_s/u`, `le_s/u`, `ge_s/u` |
+| i64 Arithmetic | `add`, `sub`, `mul`, `div_s/u`, `rem_s/u`, `clz`, `ctz`, `popcnt` |
+| i64 Bitwise | `and`, `or`, `xor`, `shl`, `shr_s/u`, `rotl`, `rotr` |
+| i64 Comparison | `eqz`, `eq`, `ne`, `lt_s/u`, `gt_s/u`, `le_s/u`, `ge_s/u` |
+| f32/f64 Comparison | `eq`, `ne`, `lt`, `gt`, `le`, `ge` |
+| Memory Loads | `i32/i64/f32/f64.load`, sign/zero-extending variants (8/16/32-bit) |
+| Memory Stores | `i32/i64/f32/f64.store`, narrowing variants (8/16/32-bit) |
+| Memory Mgmt | `memory.size`, `memory.grow` |
+
+### Parsed sections
+
+Type, Function, Export, Code, Global, Memory, Start, Data, Import (stub), Table (stub), Element (stub), Custom (stub).
+
+## Constraints
+
+- **Standard Pascal only** — no runtime library, no classes.
+- **Kernel-compatible** — all arithmetic (including `shr_s`) uses manual implementations, no RTL intrinsics.
+- **Emulation layer** — `src/emu/` mirrors the real Asuro kernel API; only these interfaces are available.
+
+## Requirements
+
+- [Free Pascal Compiler](https://www.freepascal.org/) 3.2.2+ (x86_64-win64)
+- Windows (build script is a `.bat` file)
+
+## Building
+
+```bat
+# Normal build
+build.bat
+
+# Build with test suite
+build.bat test
+```
+
+Output: `bin\WASURO.exe`
+
+## Testing
+
+```bat
+build.bat test
+bin\WASURO.exe
+```
+
+Runs 374 tests across 108 test units. Exit code equals the number of failed tests (0 on success), making it CI/CD-friendly.
+
+## License
+
+See repository for license details.
@@ -0,0 +1,78 @@
+@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=
+set DO_CLEAN=0
+set DO_RUN=0
+
+:parse_args
+if "%1"=="" goto args_done
+if "%1"=="test" set TESTFLAGS=-dRUN_TESTS
+if "%1"=="clean" set DO_CLEAN=1
+if "%1"=="run" set DO_RUN=1
+if "%1"=="help" (
+    echo Usage: build.bat [options]
+    echo Options:
+    echo   test   - Build with tests enabled
+    echo   clean  - Clean build outputs
+    echo   run    - Run the built executable after building
+    echo   help   - Show this help message
+    exit /b 0
+)
+shift
+goto parse_args
+:args_done
+
+if %DO_CLEAN%==1 (
+    echo Cleaning build outputs...
+    if exist "%BIN%" rd /s /q "%BIN%"
+    if exist "%LIB%" rd /s /q "%LIB%"
+    echo Clean complete.
+    if "%TESTFLAGS%"=="" if %DO_RUN%==0 exit /b 0
+)
+
+if not exist "%BIN%" mkdir "%BIN%"
+if not exist "%LIB%" mkdir "%LIB%"
+
+REM ── Lint ────────────────────────────────────────────────────────────
+powershell -NoProfile -ExecutionPolicy Bypass -File "%ROOT%lint.ps1" -SrcRoot "%SRC%"
+if %ERRORLEVEL% NEQ 0 exit /b 1
+
+REM ── Build ────────────────────────────────────────────────────────────
+"%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\binaries" ^
+  -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
+
+REM ── Run ────────────────────────────────────────────────────────────
+if %DO_RUN%==1 (
+    echo Running WASURO...
+    "%BIN%\WASURO.exe"
+)
@@ -0,0 +1,48 @@
+# lint.ps1 — Static lint rules for the WASURO project
+# Called by build.bat 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.'
@@ -7,20 +7,30 @@ uses

    types,

-    wasm.types,
+    wasm.types.context,
    wasm.parser,
-    wasm.vm, wasm.test.binary,
-    wasm.types.stack;
+    wasm.vm, wasm.test.binary.return42,
+    wasm.types.stack
+    {$IFDEF RUN_TESTS}
+    , wasm.test
+    , wasm.test.framework
+    {$ENDIF}
+    ;

 var
   Context : PWASMProcessContext;

 begin
+    {$IFDEF RUN_TESTS}
+    wasm.vm.init();
+    wasm.test.run_all_tests;
+    halt(wasm.test.framework.FailedTests);
+    {$ELSE}
    writestringln('[main] Initializing VM');
    wasm.vm.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));
+    Context:= wasm.parser.parse(@wasm.test.binary.return42.BINARY[0], puint8(@wasm.test.binary.return42.BINARY[0] + wasm.test.binary.return42.BINARY_SIZE));

    writestringln('[main] Running...');
    Context^.ExecutionState.Running:= true;
@@ -32,5 +42,6 @@ begin
    end;
    writeln();
    while true do sleep(1000);
+    {$ENDIF}
 end.

@@ -3,16 +3,16 @@ unit wasm.parser.sections.codeSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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,17 +59,17 @@ 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: ');
@@ -77,7 +77,7 @@ begin

    // 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 +158,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,12 +171,12 @@ 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);
@@ -3,14 +3,14 @@ unit wasm.parser.sections.customSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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);
@@ -3,31 +3,31 @@ unit wasm.parser.sections.dataSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types, wasm.types.heap;
+    wasm.types.builtin, lmemorymanager, console, leb128,
+    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 handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   pos, bend : puint8;
-   bytesRead : uint8;
-   segCount : uint32;
-   i, j : uint32;
-   memIdx : uint32;
-   offset : uint32;
-   dataSize : uint32;
-   opcode : uint8;
-   tmpU32 : uint32;
+   pos, bend : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
+   segCount : TWASMUInt32;
+   i, j : TWASMUInt32;
+   memIdx : TWASMUInt32;
+   offset : TWASMUInt32;
+   dataSize : TWASMUInt32;
+   opcode : TWASMUInt8;
+   tmpU32 : TWASMUInt32;

 begin
    writestring('[wasm.parser] Handle Section: Data - Size: ');
    writeintlnWND(section_length, 0);

    pos := buffer;
-    bend := puint8(buffer + section_length);
+    bend := TWASMPUInt8(buffer + section_length);

    { Read segment count }
    bytesRead := read_leb128_to_uint32(pos, bend, @segCount);
@@ -3,14 +3,14 @@ unit wasm.parser.sections.elementSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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: Element - Size: ');
    writeintlnWND(section_length, 0);
@@ -3,17 +3,17 @@ unit wasm.parser.sections.exportSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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,12 +28,12 @@ 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: ');
@@ -41,7 +41,7 @@ begin

    // 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 +69,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^);
@@ -3,17 +3,17 @@ unit wasm.parser.sections.functionSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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,12 +24,12 @@ 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: ');
@@ -37,7 +37,7 @@ begin

    // 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)));
@@ -3,16 +3,16 @@ unit wasm.parser.sections.globalSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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,25 @@ 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);

    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 +88,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
@@ -3,14 +3,14 @@ unit wasm.parser.sections.importSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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: Import - Size: ');
    writeintlnWND(section_length, 0);
@@ -3,16 +3,16 @@ unit wasm.parser.sections.memorySection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types, wasm.types.heap;
+    wasm.types.builtin, lmemorymanager, console, 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,21 @@ 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);

    pos := buffer;
-    bend := puint8(buffer + section_length);
+    bend := TWASMPUInt8(buffer + section_length);

    { Read memory count }
    bytesRead := read_leb128_to_uint32(pos, bend, @memCount);
@@ -3,25 +3,25 @@ unit wasm.parser.sections.startSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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);
 var
-   bytesRead : uint8;
-   funcIdx : uint32;
+   bytesRead : TWASMUInt8;
+   funcIdx : TWASMUInt32;

 begin
    writestring('[wasm.parser] Handle Section: Start - Size: ');
    writeintlnWND(section_length, 0);

    { Read the start function index }
-    bytesRead := read_leb128_to_uint32(buffer, puint8(buffer + section_length), @funcIdx);
-    ctx^.Sections.StartIndex := int32(funcIdx);
+    bytesRead := read_leb128_to_uint32(buffer, TWASMPUInt8(buffer + section_length), @funcIdx);
+    ctx^.Sections.StartIndex := TWASMInt32(funcIdx);

    writestring('[wasm.parser]     Start Function Index: ');
    writeintlnWND(funcIdx, 0);
@@ -3,14 +3,14 @@ unit wasm.parser.sections.tableSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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: Table - Size: ');
    writeintlnWND(section_length, 0);
@@ -3,10 +3,10 @@ unit wasm.parser.sections.typeSection;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types.builtin, lmemorymanager, console, 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

@@ -14,10 +14,10 @@ procedure walk(ctx : PWASMProcessContext);
 var
   currentType : PWASMType;
   currentParam : PWASMParam;
-   i,j : uint32;
+   i,j : TWASMUInt32;

 begin
-     // Walk the types
+     // Walk the wasm.types.builtin
     for i:=1 to ctx^.Sections.TypeSection^.TypeCount do begin
          currentType:= @ctx^.Sections.TypeSection^.Types[i - 1];
          writestring('[wasm.parser]     Index: ');
@@ -50,13 +50,13 @@ begin
     end;
 end;

-procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+procedure handle(buffer: TWASMPUInt8; section_length: TWASMUInt32; ctx: PWASMProcessContext);
 var
-   pos : puint8;
-   bytesRead : uint8;
+   pos : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
   currentType : PWASMType;
   currentParam : PWASMParam;
-   i, parsedTypes : uint32;
+   i, parsedTypes : TWASMUInt32;

 begin
     writestring('[wasm.parser] Handle Section: Type - Size: ');
@@ -67,31 +67,31 @@ begin
     ctx^.Sections.TypeSection:= PWASMTypeSection(kalloc(sizeof(TWASMTypeSection)));
     ctx^.Sections.TypeSection^.TypeCount:= 0;

-     // Read the number of function types
-     bytesRead:= read_leb128_to_uint32(buffer, puint8(buffer + section_length), @ctx^.Sections.TypeSection^.TypeCount);
+     // Read the number of function wasm.types.builtin
+     bytesRead:= read_leb128_to_uint32(buffer, TWASMPUInt8(buffer + section_length), @ctx^.Sections.TypeSection^.TypeCount);
     inc(pos, bytesRead);

-     // Read the function types
+     // Read the function wasm.types.builtin
     if(ctx^.Sections.TypeSection^.TypeCount > 0) then begin
          // Allocate the first type
          ctx^.Sections.TypeSection^.Types:= PWASMType(kalloc(sizeof(TWASMType) * ctx^.Sections.TypeSection^.TypeCount));

-          // Read the function types
+          // Read the function wasm.types.builtin
          for parsedTypes:=1 to ctx^.Sections.TypeSection^.TypeCount do begin
               currentType:= @ctx^.Sections.TypeSection^.Types[parsedTypes - 1];

               // Check if we are at the end of the buffer
-               if pos >= puint8(buffer + section_length) then Exit;
+               if pos >= TWASMPUInt8(buffer + section_length) then Exit;

               // Read the function type
               currentType^._type:= pos^;
               inc(pos);

               // Read the number of parameters
-               bytesRead:= read_leb128_to_uint32(pos, puint8(buffer + section_length), @currentType^.ParamCount);
+               bytesRead:= read_leb128_to_uint32(pos, TWASMPUInt8(buffer + section_length), @currentType^.ParamCount);
               inc(pos, bytesRead);

-               // Read the parameter types
+               // Read the parameter wasm.types.builtin
               if(currentType^.ParamCount > 0) then begin
                    currentType^.ParamTypes:= PWASMParam(kalloc(sizeof(TWASMParam) * currentType^.ParamCount));
                    for i:=1 to currentType^.ParamCount do begin
@@ -102,10 +102,10 @@ begin
               end;

               // Read the number of return values
-               bytesRead:= read_leb128_to_uint32(pos, puint8(buffer + section_length), @currentType^.ReturnCount);
+               bytesRead:= read_leb128_to_uint32(pos, TWASMPUInt8(buffer + section_length), @currentType^.ReturnCount);
               inc(pos, bytesRead);

-               // Read the return types
+               // Read the return wasm.types.builtin
               if(currentType^.ReturnCount > 0) then begin
                    currentType^.ReturnTypes:= PWASMParam(kalloc(sizeof(TWASMParam) * currentType^.ReturnCount));
                    for i:=1 to currentType^.ReturnCount do begin
@@ -117,7 +117,7 @@ begin
          end;
     end;

-     // Walk the types
+     // Walk the wasm.types.builtin
     walk(ctx);
 end;

@@ -3,11 +3,11 @@ unit wasm.parser;
 interface

 uses
-    types, lmemorymanager, console, leb128,
-    wasm.types, wasm.types.heap, wasm.types.stack,
-    wasm.parser.sections;
+    wasm.types.builtin, lmemorymanager, console, leb128,
+    wasm.types.enums, wasm.types.sections, wasm.types.context, wasm.types.heap, wasm.types.stack,
+    wasm.parser.sections, wasm.types.constants;

-function parse(buffer: puint8; buffer_end: puint8) : PWASMProcessContext;
+function parse(buffer: TWASMPUInt8; buffer_end: TWASMPUInt8) : PWASMProcessContext;

 implementation

@@ -50,13 +50,13 @@ begin
    newContext:= ctx;
 end;

-function parse(buffer: puint8; buffer_end: puint8): PWASMProcessContext;
+function parse(buffer: TWASMPUInt8; buffer_end: TWASMPUInt8): PWASMProcessContext;
 var
   ctx : PWASMProcessContext;
-   pos : puint8;
-   bytesRead : uint8;
-   section_id : uint8;
-   section_length : uint32;
+   pos : TWASMPUInt8;
+   bytesRead : TWASMUInt8;
+   section_id : TWASMUInt8;
+   section_length : TWASMUInt32;

 begin
    // Allocate the context
@@ -66,7 +66,7 @@ begin
    writestringln('[wasm.parser] Parsing WASM Binary');

    // Check for the WASM Magic
-    if(puint32(pos)^ = wasm.types.WASM_HDR_MAGIC) then begin
+    if(TWASMPUInt32(pos)^ = wasm.types.constants.WASM_HDR_MAGIC) then begin
        writestringln('[wasm.parser] Binary is valid.');

        // Set binary to valid
@@ -74,7 +74,7 @@ begin
        inc(pos, 4);

        // Read the version
-        ctx^.Version:= puint32(pos)^;
+        ctx^.Version:= TWASMPUInt32(pos)^;
        inc(pos, 4);
        writestring('[wasm.parser] Version: ');
        writeintlnWND(ctx^.Version, 0);
@@ -3,8 +3,8 @@ unit wasm.parser.sections;
 interface

 uses
-    types,
-    wasm.types,
+    wasm.types.builtin,
+    wasm.types.enums, wasm.types.context,
    wasm.parser.sections.customSection,
    wasm.parser.sections.typeSection,
    wasm.parser.sections.importSection,
@@ -18,11 +18,11 @@ uses
    wasm.parser.sections.codeSection,
    wasm.parser.sections.dataSection;

-procedure handle(sectionId : uint8; buffer : puint8; section_length : uint32; ctx : PWASMProcessContext);
+procedure handle(sectionId : TWASMUInt8; buffer : TWASMPUInt8; section_length : TWASMUInt32; ctx : PWASMProcessContext);

 implementation

-procedure handle(sectionId : uint8; buffer : puint8; section_length : uint32; ctx : PWASMProcessContext);
+procedure handle(sectionId : TWASMUInt8; buffer : TWASMPUInt8; section_length : TWASMUInt32; ctx : PWASMProcessContext);
 begin
    // Handle the section
    case sectionId of
@@ -0,0 +1,62 @@
+{ E2E test: i32.const 10 + i32.const 32 = 42
+  Equivalent WAT:
+    (module
+      (func (export "main") (result i32)
+        i32.const 10
+        i32.const 32
+        i32.add
+        return
+      )
+    )
+}
+unit wasm.test.binary.addnums;
+
+interface
+
+procedure run;
+
+implementation
+
+uses
+    wasm.types.builtin, console, wasm.types.context, wasm.types.stack,
+    wasm.parser, wasm.vm, wasm.test.framework;
+
+const
+  BINARY_SIZE = 41;
+  BINARY : Array[$00..$28] of TWASMUInt8 = (
+    $00, $61, $73, $6D,       { magic }
+    $01, $00, $00, $00,       { version 1 }
+    $01, $05, $01, $60,       { type section: 1 func type }
+    $00, $01, $7F,            { () -> (i32) }
+    $03, $02, $01, $00,       { function section: 1 func, type 0 }
+    $07, $08, $01, $04,       { export section: 1 export, name len 4 }
+    $6D, $61, $69, $6E,       { "main" }
+    $00, $00,                 { export type=func, index=0 }
+    $0A, $0A, $01, $08,       { code section: len=10, count=1, body=8 }
+    $00,                      { 0 locals }
+    $41, $0A,                 { i32.const 10 }
+    $41, $20,                 { i32.const 32 }
+    $6A,                      { i32.add }
+    $0F, $0B                  { return, end }
+  );
+
+procedure run;
+var
+    ctx : PWASMProcessContext;
+begin
+    test_begin('binary.addnums');
+
+    ctx := wasm.parser.parse(@BINARY[0], TWASMPUInt8(@BINARY[0] + BINARY_SIZE));
+    assert_true('valid binary', ctx^.ValidBinary);
+
+    ctx^.ExecutionState.Running := true;
+    while wasm.vm.tick(ctx) do;
+
+    assert_bool('execution stopped', ctx^.ExecutionState.Running, false);
+    assert_true('stack has result', ctx^.ExecutionState.Operand_Stack^.Top > 0);
+    assert_i32('10+32=42', popi32(ctx^.ExecutionState.Operand_Stack), 42);
+
+    test_end;
+end;
+
+end.
Author	SHA1	Message	Date
t3hn3rd	ff65a0d5f0	refactor: build.bat flexible argument parsing, add run & help commands - Replaced positional `%1` checks with a loop-based argument parser so flags (`test`, `clean`, `run`, `help`) work in any order/combination - Added `run` flag: executes `bin\WASURO.exe` after a successful build - Added `help` flag: prints usage info and exits - Fixed `clean` early-exit to also check `DO_RUN` (not just `TESTFLAGS`), so `build.bat clean run` correctly continues to build+run - Added section comment headers (Build, Run) for consistency	2026-02-24 14:57:30 +00:00
t3hn3rd	76d7d737c0	Merge branch 'feature/missing-opcodes' into develop	2026-02-24 14:47:01 +00:00
t3hn3rd	d12ad11746	feature: implement control flow opcodes, extract constants & helpers ## Control Flow Opcodes - Implemented all 10 remaining stub control flow opcodes: block, loop, if, else, end, br, br_if, br_table, call, call_indirect - Rewrote return opcode to walk control stack and restore call frames - Fixed tick() hang: now halts when IP >= Limit ## Refactoring - Extracted WASM_HDR_MAGIC and CTRL_FRAME_* constants to wasm.types.constants.pas - Extracted push_control_frame, scan_forward, do_branch helpers to wasm.vm.control.pas - Updated wasm.parser.pas to reference constants via wasm.types.constants ## Tests - Added 9 new test units (25 tests): block, loop, if, end, br, br_if, br_table, call, call_indirect - Added E2E binary test: 115-byte handcrafted WASM binary exercising all control flow opcodes (2 functions, expected result=30) - All 425/425 tests passing	2026-02-24 14:46:30 +00:00
t3hn3rd	679973c6e9	Merge branch 'feature/type-refactoring' into develop	2026-02-24 13:24:15 +00:00
t3hn3rd	68df3565cb	feature: types refactored from one monolithic file to seperation of duties - wasm.types.context.pas - wasm.types.enums.pas - wasm.types.sections.pas - wasm.types.values.pas	2026-02-24 13:23:46 +00:00
t3hn3rd	862e3254df	Merge branch 'hotfix/binary-test-builtins' into develop	2026-02-24 13:05:42 +00:00
t3hn3rd	6794c52a77	patch: binary-test patched to use builtin types	2026-02-24 13:05:33 +00:00
t3hn3rd	7cc4459dfd	Merge branch 'feature/builtin-types' into develop	2026-02-24 13:04:25 +00:00
t3hn3rd	ae344e7495	Merge branch 'feature/binary-tests' into develop	2026-02-24 13:04:20 +00:00
t3hn3rd	430ebcd203	feature: added built-in types as a OS/RTL->VM decoupling mechanism - Added src/wasm/types/wasm.types.builtin.pas as a decoupling unit. - Updated all units to only use these types. - Added linter step (lint.ps1) to enforce usage of these types.	2026-02-24 13:03:27 +00:00
t3hn3rd	835f6f86cc	feature: Binary E2E tests Implemented the following E2E tests: - src/wasm/test/wasm.test.binary.addnums.pas - src/wasm/test/wasm.test.binary.arithmetic.pas - src/wasm/test/wasm.test.binary.locals.pas - src/wasm/test/wasm.test.binary.memroundtrip.pas - src/wasm/test/wasm.test.binary.return42.pas	2026-02-24 12:26:43 +00:00
t3hn3rd	a5192366ed	Merge branch 'hotfix/readme.1' into develop	2026-02-24 00:47:36 +00:00
t3hn3rd	d3cd71072b	hotfix: Fixed errors & formatting in generated ReadMe - Incorrect link to the Asuro project. - Formatting issues.	2026-02-24 00:47:23 +00:00
t3hn3rd	e40d8e9ed5	Merge branch 'feature/readme' into develop	2026-02-24 00:42:31 +00:00
t3hn3rd	fca24af1b0	docs: add project README Add README.md documenting WASURO's architecture, implemented opcodes, parsed sections, build instructions, testing, and constraints. Covers: - Project overview (WASM VM for Asuro OS, Standard Pascal, bare-metal) - Source tree layout and key components (VM, parser, stack, heap, emu layer) - Full table of implemented opcodes (control, variables, constants, i32/i64 arithmetic/bitwise/comparison, f32/f64 comparison, memory loads/stores, memory.size/grow) - Parsed WASM binary sections - Build and test instructions (build.bat / build.bat test) - Kernel compatibility constraints (no RTL, no classes)	2026-02-24 00:42:17 +00:00
t3hn3rd	8c16550bd4	Merge branch 'feature/test-suite' into develop	2026-02-24 00:38:11 +00:00
t3hn3rd	9a3b813c96	Merge branch 'feature/opcode-parser-implementation' into develop	2026-02-24 00:38:06 +00:00
t3hn3rd	8a4bb2ca35	Merge branch 'feature/build-scripts' into develop	2026-02-24 00:38:00 +00:00
t3hn3rd	ff28299132	feature: add build script and update .gitignore Add build.bat for compiling WASURO with FPC 3.2.2 (x86_64-win64). Supports optional "test" argument to enable the test suite. build.bat: - Configures FPC with all source unit paths (emu, wasm, parser, sections, types, vm, test infrastructure) - Outputs to bin/WASURO.exe, intermediate units to lib/ - "build.bat test" passes -dRUN_TESTS to include test units - Debug info enabled (-gw3) - Propagates FPC exit code on failure .gitignore: - Add AGENTS.md (AI agent instructions, not project source), this file should be personal choice, not dictated at a project level.	2026-02-24 00:37:37 +00:00
t3hn3rd	dc67262477	feature: add comprehensive WASM test suite (374 tests) Add a full test framework and 123 test files covering infrastructure, parser sections, and VM opcodes. All 374 tests pass; exit code reflects failure count for CI/CD integration. Test framework (wasm.test.framework): - Assert helpers: assert_true, assert_i32/i64/u32/u64/f32/f64/bool - Context builders: make_test_context, setup_test_locals, setup_test_globals - Global counters: TotalTests, PassedTests, FailedTests Test runner (wasm.test, WASURO.lpr): - Master runner calls all 108 test units and prints summary - halt(FailedTests) returns exit code for pipeline consumption - Gated behind {$IFDEF RUN_TESTS} / build.bat test Infrastructure tests (3 units): - Stack push/pop for i32, i64, f32, f64 - Heap read/write across all widths (8/16/32/64-bit) - LEB128 unsigned/signed encoding/decoding Parser tests (8 units): - type, function, export, code, global, memory, start, data sections Opcode tests (97 units, ~374 assertions): - Control: nop, unreachable, drop, select, return - Variables: local.get/set/tee, global.get/set - Constants: i32/i64/f32/f64.const - I32: all arithmetic, bitwise, and comparison ops (29 units) - I64: all arithmetic, bitwise, and comparison ops (29 units) - F32/F64: all comparison ops (12 units) - Memory loads: i32/i64/f32/f64.load + sign/zero-extending variants (14 units) - Memory stores: i32/i64/f32/f64.store + narrowing variants (9 units)	2026-02-24 00:34:49 +00:00