acaaac5 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

acaaac5 — Peter John 2026-11-02T16:16:50+05:30

Add Mem linear-memory primitive and GameCmd command-buffer game API

Files changed (4) hide show

plum-std/GameCmd.plum +316 -0
plum-std/Mem.plum +48 -0
plum-wasm-codegen/src/lib.rs +95 -1
plum-wasm-codegen/tests/codegen_tests.rs +86 -0

plum-std/GameCmd.plum ADDED Viewed

@@ -0,0 +1,316 @@
+module std
+import std/Int
+import std/Float
+import std/Str
+import std/Vec2
+import std/Color
+import std/Mem
+# `std/Game` with the draw calls recorded into a command buffer in linear
+# memory instead of being imported from the host: `import std/GameCmd` replaces
+# `import std/Game` unchanged. Input, assets, sound and screen queries stay host
+# externs; `clear`, `drawRect`, `drawCircle`, `drawLine`, `drawText`,
+# `drawTexture`, `drawTextureEx`, `setCamera` and `resetCamera` append commands
+# that the host reads from the exported `memory` after `draw` (`cmdPtr`,
+# `cmdLen`), and `cmdReset` empties the buffer.
+#
+# Layout: byte 0 holds the i32 count of command bytes written since the last
+# `cmdReset` (zero in fresh memory); commands start at byte 16, and the buffer
+# grows the memory as needed. Everything is little-endian, every field is 4
+# bytes (f32 for Float, i32 for Int and Bool), and a command is a u32 opcode
+# followed by its fields:
+#   1 clear      r g b a
+#   2 rect       x y w h r g b a
+#   3 line       x1 y1 x2 y2 thickness r g b a
+#   4 circle     x y radius r g b a
+#   5 text       x y size r g b a byteLen, then the UTF-8 bytes zero-padded to a multiple of 4
+#   6 texture    tex x y r g b a
+#   7 textureEx  tex sx sy sw sh x y w h rotation flipX r g b a
+#   8 setCamera  x y scale
+#   9 resetCamera
+# Texture and sound handles are -1 on failure. File, texture and sound paths are
+# relative to the asset root. Coordinates are world units once `setCamera` is set.
+extern fun screenWidth() -> Float
+extern fun screenHeight() -> Float
+extern fun frameTime() -> Float
+# Empties the command buffer; the host calls it before `draw`.
+export fun cmdReset() =
+  Mem.storeI32(0, 0)
+# Byte offset of this frame's first command.
+export fun cmdPtr() -> Int =
+  16
+# Length in bytes of this frame's commands.
+export fun cmdLen() -> Int =
+  Mem.loadI32(0)
+# Reserves a command of `n` field bytes, writes its opcode and returns the
+# address of its first field.
+fun cmdBegin(op: Int, n: Int) -> Int =
+  used := Mem.loadI32(0)
+  at := 16 + used
+  end := at + 4 + n
+  size := Mem.size()
+  if end > size
+    need := {end - size + 65535} / 65536
+    _ := Mem.grow(if need < 16 then 16 else need)
+  Mem.storeI32(0, used + 4 + n)
+  Mem.storeI32(at, op)
+  at + 4
+fun cmdColor(at: Int, c: Color) =
+  Mem.storeF32(at, c.r)
+  Mem.storeF32(at + 4, c.g)
+  Mem.storeF32(at + 8, c.b)
+  Mem.storeF32(at + 12, c.a)
+fun clear(c: Color) =
+  a := cmdBegin(1, 16)
+  cmdColor(a, c)
+fun drawRect(x: Float, y: Float, w: Float, h: Float, c: Color) =
+  a := cmdBegin(2, 32)
+  Mem.storeF32(a, x)
+  Mem.storeF32(a + 4, y)
+  Mem.storeF32(a + 8, w)
+  Mem.storeF32(a + 12, h)
+  cmdColor(a + 16, c)
+fun drawCircle(x: Float, y: Float, r: Float, c: Color) =
+  a := cmdBegin(4, 28)
+  Mem.storeF32(a, x)
+  Mem.storeF32(a + 4, y)
+  Mem.storeF32(a + 8, r)
+  cmdColor(a + 12, c)
+fun drawLine(x1: Float, y1: Float, x2: Float, y2: Float, thickness: Float, c: Color) =
+  a := cmdBegin(3, 36)
+  Mem.storeF32(a, x1)
+  Mem.storeF32(a + 4, y1)
+  Mem.storeF32(a + 8, x2)
+  Mem.storeF32(a + 12, y2)
+  Mem.storeF32(a + 16, thickness)
+  cmdColor(a + 20, c)
+fun drawText(s: Str, x: Float, y: Float, size: Float, c: Color) =
+  n := s.length()
+  padded := {n + 3} / 4 * 4
+  a := cmdBegin(5, 32 + padded)
+  Mem.storeF32(a, x)
+  Mem.storeF32(a + 4, y)
+  Mem.storeF32(a + 8, size)
+  cmdColor(a + 12, c)
+  Mem.storeI32(a + 28, n)
+  i := 0
+  while i < padded
+    Mem.storeU8(a + 32 + i, if i < n then s.byteAt(i) else 0)
+    i = i + 1
+fun setCamera(x: Float, y: Float, scale: Float) =
+  a := cmdBegin(8, 12)
+  Mem.storeF32(a, x)
+  Mem.storeF32(a + 4, y)
+  Mem.storeF32(a + 8, scale)
+fun resetCamera() =
+  _ := cmdBegin(9, 0)
+# The texture at its natural size, top-left at (x, y).
+fun drawTexture(t: Int, x: Float, y: Float, tint: Color) =
+  a := cmdBegin(6, 28)
+  Mem.storeI32(a, t)
+  Mem.storeF32(a + 4, x)
+  Mem.storeF32(a + 8, y)
+  cmdColor(a + 12, tint)
+# The source rect (sx, sy, sw, sh) in texture pixels drawn into the dest rect
+# (x, y, w, h), rotated `rotation` radians clockwise about the dest centre.
+fun drawTextureEx(t: Int, sx: Float, sy: Float, sw: Float, sh: Float, x: Float, y: Float, w: Float, h: Float, rotation: Float, flipX: Bool, tint: Color) =
+  a := cmdBegin(7, 60)
+  Mem.storeI32(a, t)
+  Mem.storeF32(a + 4, sx)
+  Mem.storeF32(a + 8, sy)
+  Mem.storeF32(a + 12, sw)
+  Mem.storeF32(a + 16, sh)
+  Mem.storeF32(a + 20, x)
+  Mem.storeF32(a + 24, y)
+  Mem.storeF32(a + 28, w)
+  Mem.storeF32(a + 32, h)
+  Mem.storeF32(a + 36, rotation)
+  Mem.storeI32(a + 40, if flipX then 1 else 0)
+  cmdColor(a + 44, tint)
+# Loads any image the host decodes (PNG at least); -1 on failure.
+extern fun textureLoad(path: Str) -> Int
+# Size in pixels; 0 for a bad handle.
+extern fun textureWidth(t: Int) -> Int
+extern fun textureHeight(t: Int) -> Int
+# Linear (true) or nearest (false, the default) filtering.
+extern fun textureSetSmooth(t: Int, smooth: Bool)
+extern fun fileExists(path: Str) -> Bool
+# The whole file; "" if it is missing.
+extern fun fileLoad(path: Str) -> Str
+# Loads a WAV or OGG file relative to the asset root; -1 on failure. The host
+# decodes every sound file in the asset root before `init` runs.
+extern fun soundLoad(path: Str) -> Int
+# A one-shot play; plays of the same sound may overlap. Volume is 0..1.
+extern fun soundPlay(s: Int, volume: Float)
+# Starts the sound looping. Call `soundStop` first to restart it cleanly.
+extern fun soundLoop(s: Int, volume: Float)
+# Stops every play and loop of the sound.
+extern fun soundStop(s: Int)
+# Changes the volume of a sound that is playing or looping.
+extern fun soundSetVolume(s: Int, volume: Float)
+extern fun isKeyDown(k: Int) -> Bool
+extern fun isKeyPressed(k: Int) -> Bool
+extern fun mousePos() -> Vec2
+extern fun isMouseDown(b: Int) -> Bool
+extern fun isMousePressed(b: Int) -> Bool
+extern fun mouseWheel() -> Float
+# Key codes (GLFW numbering) for `isKeyDown` / `isKeyPressed`.
+# Letter keys are `KeyA`..`KeyZ` (a constant name needs two characters).
+primitive Key =
+  Space = 32
+  KeyA = 65
+  KeyB = 66
+  KeyC = 67
+  KeyD = 68
+  KeyE = 69
+  KeyF = 70
+  KeyG = 71
+  KeyH = 72
+  KeyI = 73
+  KeyJ = 74
+  KeyK = 75
+  KeyL = 76
+  KeyM = 77
+  KeyN = 78
+  KeyO = 79
+  KeyP = 80
+  KeyQ = 81
+  KeyR = 82
+  KeyS = 83
+  KeyT = 84
+  KeyU = 85
+  KeyV = 86
+  KeyW = 87
+  KeyX = 88
+  KeyY = 89
+  KeyZ = 90
+  Num0 = 48
+  Num1 = 49
+  Num2 = 50
+  Num3 = 51
+  Num4 = 52
+  Num5 = 53
+  Num6 = 54
+  Num7 = 55
+  Num8 = 56
+  Num9 = 57
+  Escape = 256
+  Enter = 257
+  Tab = 258
+  Backspace = 259
+  Right = 262
+  Left = 263
+  Down = 264
+  Up = 265
+  LeftShift = 340
+  LeftControl = 341
+# Mouse button numbers for `isMouseDown` / `isMousePressed`.
+primitive Mouse =
+  Left = 0
+  Right = 1
+  Middle = 2
+test "key and mouse constants use GLFW numbering"
+  assert Key.KeyW == 87
+  assert Key.Left == 263
+  assert Mouse.Right == 1
+test "draw calls encode one command each"
+  cmdReset()
+  assert cmdPtr() == 16
+  assert cmdLen() == 0
+  clear(Color(r: 0.25, g: 0.5, b: 0.75, a: 1.0))
+  drawRect(1.0, 2.0, 3.0, 4.0, Color.Red)
+  assert cmdLen() == 20 + 36
+  assert Mem.loadI32(16) == 1
+  assert Mem.loadF32(20) == 0.25
+  assert Mem.loadF32(32) == 1.0
+  assert Mem.loadI32(36) == 2
+  assert Mem.loadF32(40) == 1.0
+  assert Mem.loadF32(52) == 4.0
+  assert Mem.loadF32(56) == 1.0
+  assert Mem.loadF32(60) == 0.0
+  cmdReset()
+  drawLine(1.0, 2.0, 3.0, 4.0, 5.0, Color.Green)
+  drawCircle(6.0, 7.0, 8.0, Color.Blue)
+  assert Mem.loadI32(16) == 3
+  assert Mem.loadF32(36) == 5.0
+  assert Mem.loadF32(40) == 0.0
+  assert Mem.loadF32(44) == 1.0
+  assert Mem.loadI32(56) == 4
+  assert Mem.loadF32(60) == 6.0
+  assert Mem.loadF32(68) == 8.0
+  assert Mem.loadF32(80) == 1.0
+  assert cmdLen() == 40 + 32
+test "texture, camera and reset commands"
+  cmdReset()
+  drawTexture(9, 1.5, 2.5, Color.White)
+  assert Mem.loadI32(16) == 6
+  assert Mem.loadI32(20) == 9
+  assert Mem.loadF32(28) == 2.5
+  assert cmdLen() == 32
+  cmdReset()
+  drawTextureEx(3, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 0.5, true, Color.Black)
+  assert Mem.loadI32(16) == 7
+  assert Mem.loadI32(20) == 3
+  assert Mem.loadF32(56) == 0.5
+  assert Mem.loadI32(60) == 1
+  assert Mem.loadF32(76) == 1.0
+  assert cmdLen() == 64
+  cmdReset()
+  setCamera(1.0, 2.0, 3.0)
+  resetCamera()
+  assert Mem.loadI32(16) == 8
+  assert Mem.loadF32(28) == 3.0
+  assert Mem.loadI32(32) == 9
+  assert cmdLen() == 20
+test "text is length-prefixed and zero-padded to 4 bytes"
+  cmdReset()
+  drawText("hello", 1.0, 2.0, 12.0, Color.White)
+  assert Mem.loadI32(16) == 5
+  assert Mem.loadF32(28) == 12.0
+  assert Mem.loadI32(48) == 5
+  assert Mem.loadU8(52) == 104
+  assert Mem.loadU8(56) == 111
+  assert Mem.loadU8(57) == 0
+  assert Mem.loadU8(59) == 0
+  assert cmdLen() == 4 + 32 + 8
+  drawText("abcd", 0.0, 0.0, 1.0, Color.White)
+  assert cmdLen() == 44 + 4 + 32 + 4
+  drawText("", 0.0, 0.0, 1.0, Color.White)
+  assert cmdLen() == 84 + 36
+test "the buffer grows memory past the initial pages"
+  cmdReset()
+  i := 0
+  while i < 40000
+    drawRect(1.0, 2.0, 3.0, 4.0, Color.Red)
+    i = i + 1
+  assert cmdLen() == 40000 * 36
+  assert Mem.size() > 16 * 65536
+  assert Mem.loadI32(16 + 39999 * 36) == 2
+  assert Mem.loadF32(16 + 39999 * 36 + 8) == 2.0
+  cmdReset()
+  assert cmdLen() == 0

plum-std/Mem.plum ADDED Viewed

@@ -0,0 +1,48 @@
+module std
+import std/Int
+import std/Float
+# The program's linear memory: one growable wasm memory (16 pages of 64 KiB to
+# start), exported to the host as "memory". Present only in programs that use
+# `Mem`. Addresses are byte offsets; every access is little-endian and traps
+# when out of bounds. Integers are stored as 32 bits (`storeI32` truncates,
+# `loadI32` sign-extends) and floats as f32.
+primitive Mem =
+  # Current memory size in bytes.
+  fun size() -> Int =
+    todo
+  # Adds `pages` 64 KiB pages; returns the old page count, or -1 on failure.
+  fun grow(pages: Int) -> Int =
+    todo
+  fun storeF32(addr: Int, v: Float) =
+    todo
+  fun storeI32(addr: Int, v: Int) =
+    todo
+  # Stores the low 8 bits of `v`.
+  fun storeU8(addr: Int, v: Int) =
+    todo
+  fun loadF32(addr: Int) -> Float =
+    todo
+  fun loadI32(addr: Int) -> Int =
+    todo
+  # The byte at `addr`, 0..255.
+  fun loadU8(addr: Int) -> Int =
+    todo
+test "Mem round trips"
+  Mem.storeI32(16, -5)
+  assert Mem.loadI32(16) == -5
+  Mem.storeF32(32, 1.5f)
+  assert Mem.loadF32(32) == 1.5f
+  Mem.storeU8(40, 300)
+  assert Mem.loadU8(40) == 44
+  assert Mem.size() == 1048576
+  assert Mem.grow(1) == 16
+  assert Mem.size() == 1114112

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -49,6 +49,8 @@ pub struct WasmModule {
     global_count: u32,
     start_function: Option<u32>,
     func_names: Vec<(u32, String)>,
+    /// Initial page count of the module's one linear memory, when it has one.
+    memory_pages: Option<u64>,
 }
 impl WasmModule {
@@ -67,9 +69,16 @@ impl WasmModule {
             global_count: 0,
             start_function: None,
             func_names: Vec::new(),
+            memory_pages: None,
         }
     }
+    /// Declares the module's single growable linear memory (`min_pages` initial
+    /// pages) and exports it as "memory".
+    pub fn enableMemory(&mut self, min_pages: u64) {
+        self.memory_pages = Some(min_pages);
+    }
     pub fn addType(&mut self, params: &[ValType], results: &[ValType]) -> u32 {
         let idx = self.next_type_idx;
         self.types.push(TypeEntry::Func(FuncType::new(
@@ -218,6 +227,19 @@ impl WasmModule {
             module.section(&tables);
         }
+        // Memory section
+        if let Some(min) = self.memory_pages {
+            let mut mems = wasm_encoder::MemorySection::new();
+            mems.memory(wasm_encoder::MemoryType {
+                minimum: min,
+                maximum: None,
+                memory64: false,
+                shared: false,
+                page_size_log2: None,
+            });
+            module.section(&mems);
+        }
         // Global section
         if !self.globals.is_empty() {
             let mut globals = GlobalSection::new();
@@ -236,8 +258,11 @@ impl WasmModule {
         }
         // Export section
-        if !self.exports.is_empty() {
+        if !self.exports.is_empty() || self.memory_pages.is_some() {
             let mut exports = ExportSection::new();
+            if self.memory_pages.is_some() {
+                exports.export("memory", ExportKind::Memory, 0);
+            }
             for (name, kind, idx) in &self.exports {
                 exports.export(name, *kind, *idx);
             }
@@ -2758,6 +2783,9 @@ fn compileSourceInner(
         };
         compiled_bodies.push((idx, body));
     }
+    if units.iter().any(|u| u.f.type_param.as_deref() == Some("Mem")) {
+        module.enableMemory(16);
+    }
     for (idx, body) in &compiled_bodies {
         let slot = (*idx - module.func_import_count) as usize;
         module.functions[slot].1 = body.clone();
@@ -3014,6 +3042,9 @@ fn getClosureCallType(
 /// Returns `None` for any other function, meaning "compile it normally."
 fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
     if let Some(recv) = f.type_param.as_deref() {
+        if recv == "Mem" {
+            return compileMemIntrinsicFnBody(f);
+        }
         if isArraySpecialization(recv) {
             return compileArrayIntrinsicFnBody(f, subst);
         }
@@ -3021,6 +3052,69 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
     None
 }
+/// `Mem`'s linear-memory primitives. Local 0 is the unused static `self` slot,
+/// so the declared params start at local 1. Addresses and values are `Int`
+/// (i64) wrapped to i32; `Float` is demoted to / promoted from f32.
+fn compileMemIntrinsicFnBody(f: &ast::Fn) -> Option<Vec<u8>> {
+    let mut body = vec![0u8];
+    let arg = |b: &mut Vec<u8>, local: u32| {
+        Instruction::LocalGet(local).encode(b);
+        Instruction::I32WrapI64.encode(b);
+    };
+    let mem = |align| wasm_encoder::MemArg {
+        offset: 0,
+        align,
+        memory_index: 0,
+    };
+    match f.name.as_str() {
+        "size" => {
+            Instruction::MemorySize(0).encode(&mut body);
+            Instruction::I64ExtendI32U.encode(&mut body);
+            Instruction::I64Const(65536).encode(&mut body);
+            Instruction::I64Mul.encode(&mut body);
+        }
+        "grow" => {
+            arg(&mut body, 1);
+            Instruction::MemoryGrow(0).encode(&mut body);
+            Instruction::I64ExtendI32S.encode(&mut body);
+        }
+        "storeF32" => {
+            arg(&mut body, 1);
+            Instruction::LocalGet(2).encode(&mut body);
+            Instruction::F32DemoteF64.encode(&mut body);
+            Instruction::F32Store(mem(0)).encode(&mut body);
+        }
+        "storeI32" => {
+            arg(&mut body, 1);
+            arg(&mut body, 2);
+            Instruction::I32Store(mem(0)).encode(&mut body);
+        }
+        "storeU8" => {
+            arg(&mut body, 1);
+            arg(&mut body, 2);
+            Instruction::I32Store8(mem(0)).encode(&mut body);
+        }
+        "loadF32" => {
+            arg(&mut body, 1);
+            Instruction::F32Load(mem(0)).encode(&mut body);
+            Instruction::F64PromoteF32.encode(&mut body);
+        }
+        "loadI32" => {
+            arg(&mut body, 1);
+            Instruction::I32Load(mem(0)).encode(&mut body);
+            Instruction::I64ExtendI32S.encode(&mut body);
+        }
+        "loadU8" => {
+            arg(&mut body, 1);
+            Instruction::I32Load8U(mem(0)).encode(&mut body);
+            Instruction::I64ExtendI32U.encode(&mut body);
+        }
+        _ => return None,
+    }
+    Instruction::End.encode(&mut body);
+    Some(body)
+}
 /// Wraps a just-pushed raw `array<i8>` (top of the value stack, whose length
 /// IS the string's length) into `Str`'s `(data, start: 0, len)` representation via
 /// `mk_str_fn`. Every codegen site that builds a `Str` from raw bytes goes

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -3115,3 +3115,89 @@ fun main() -> Int =
 ";
     assert_eq!(runInt(src), 3);
 }
+// ---- Mem: linear memory primitive ----
+#[test]
+fn memRoundTripsAndGrows() {
+    let src = "\
+import std/Int
+import std/Float
+import std/Mem
+fun main() -> Int =
+  Mem.storeI32(8, -7)
+  Mem.storeF32(12, 2.5f)
+  Mem.storeU8(16, 513)
+  ok := Mem.loadI32(8) == -7 && Mem.loadF32(12) == 2.5f && Mem.loadU8(16) == 1
+  before := Mem.size()
+  old := Mem.grow(2)
+  if ok && before == 16 * 65536 && old == 16 && Mem.size() == 18 * 65536 && Mem.grow(100000) == -1
+    return 1
+  0
+";
+    assert_eq!(runMerged::<i64>("mem_roundtrip", src), 1);
+}
+#[test]
+fn memOutOfBoundsTraps() {
+    let src = "\
+import std/Int
+import std/Mem
+fun main() -> Int =
+  Mem.loadI32(16 * 65536)
+";
+    let dir = std::env::temp_dir().join(format!("plum_mem_oob_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let bytes = compileSource(&source).expect("compile");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let inst = linker.instantiate(&mut store, &module).unwrap();
+    let main = inst.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    assert!(main.call(&mut store, ()).is_err());
+    let _ = std::fs::remove_dir_all(&dir);
+}
+#[test]
+fn memoryExportedOnlyWhenMemUsed() {
+    let with = "\
+import std/Int
+import std/Mem
+fun main() -> Int =
+  Mem.size()
+";
+    let without = "import std/Int\n\nfun main() -> Int =\n  1\n";
+    let exportsMemory = |name: &str, src: &str| {
+        let (bytes, _) = compiledKeys(name, src);
+        let mut mem = false;
+        let mut exports_memory = false;
+        for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
+            match payload.unwrap() {
+                wasmparser::Payload::MemorySection(_) => mem = true,
+                wasmparser::Payload::ExportSection(r) => {
+                    for e in r {
+                        let e = e.unwrap();
+                        if e.name == "memory" && e.kind == wasmparser::ExternalKind::Memory {
+                            exports_memory = true;
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        assert_eq!(mem, exports_memory);
+        mem
+    };
+    assert!(exportsMemory("mem_with", with));
+    assert!(!exportsMemory("mem_without", without));
+}