implemented intrinsecs de input and specs adjustment
This commit is contained in:
@@ -19,7 +19,7 @@ pub use resolver::{
|
||||
/// Each Syscall has a unique 32-bit ID. The IDs are grouped by category:
|
||||
/// - **0x0xxx**: System & OS Control
|
||||
/// - **0x1xxx**: Graphics (GFX)
|
||||
/// - **0x2xxx**: Input (Gamepad & Touch)
|
||||
/// - **0x2xxx**: Reserved for legacy input syscalls (disabled for v1 VM-owned input)
|
||||
/// - **0x3xxx**: Audio (PCM & Mixing)
|
||||
/// - **0x4xxx**: Filesystem (Sandboxed I/O)
|
||||
/// - **0x5xxx**: Logging & Debugging
|
||||
@@ -38,31 +38,6 @@ pub enum Syscall {
|
||||
GfxSetSprite = 0x1007,
|
||||
GfxDrawText = 0x1008,
|
||||
GfxClear565 = 0x1010,
|
||||
InputGetPad = 0x2001,
|
||||
InputGetPadPressed = 0x2002,
|
||||
InputGetPadReleased = 0x2003,
|
||||
InputGetPadHold = 0x2004,
|
||||
InputPadSnapshot = 0x2010,
|
||||
InputTouchSnapshot = 0x2011,
|
||||
TouchGetX = 0x2101,
|
||||
TouchGetY = 0x2102,
|
||||
TouchIsDown = 0x2103,
|
||||
TouchIsPressed = 0x2104,
|
||||
TouchIsReleased = 0x2105,
|
||||
TouchGetHold = 0x2106,
|
||||
TouchGetFinger = 0x2107,
|
||||
PadGetUp = 0x2200,
|
||||
PadGetDown = 0x2201,
|
||||
PadGetLeft = 0x2202,
|
||||
PadGetRight = 0x2203,
|
||||
PadGetA = 0x2204,
|
||||
PadGetB = 0x2205,
|
||||
PadGetX = 0x2206,
|
||||
PadGetY = 0x2207,
|
||||
PadGetL = 0x2208,
|
||||
PadGetR = 0x2209,
|
||||
PadGetStart = 0x220A,
|
||||
PadGetSelect = 0x220B,
|
||||
AudioPlaySample = 0x3001,
|
||||
AudioPlay = 0x3002,
|
||||
FsOpen = 0x4001,
|
||||
|
||||
@@ -1,305 +0,0 @@
|
||||
use super::entry;
|
||||
use crate::syscalls::{Determinism, Syscall, SyscallRegistryEntry, caps};
|
||||
|
||||
pub(crate) const ENTRIES: &[SyscallRegistryEntry] = &[
|
||||
entry(
|
||||
Syscall::InputGetPad,
|
||||
"input",
|
||||
"get_pad",
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::InputGetPadPressed,
|
||||
"input",
|
||||
"get_pad_pressed",
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::InputGetPadReleased,
|
||||
"input",
|
||||
"get_pad_released",
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::InputGetPadHold,
|
||||
"input",
|
||||
"get_pad_hold",
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::InputPadSnapshot,
|
||||
"input",
|
||||
"pad_snapshot",
|
||||
1,
|
||||
0,
|
||||
48,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::InputTouchSnapshot,
|
||||
"input",
|
||||
"touch_snapshot",
|
||||
1,
|
||||
0,
|
||||
6,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchGetX,
|
||||
"input",
|
||||
"touch_get_x",
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchGetY,
|
||||
"input",
|
||||
"touch_get_y",
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchIsDown,
|
||||
"input",
|
||||
"touch_is_down",
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchIsPressed,
|
||||
"input",
|
||||
"touch_is_pressed",
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchIsReleased,
|
||||
"input",
|
||||
"touch_is_released",
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchGetHold,
|
||||
"input",
|
||||
"touch_get_hold",
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::TouchGetFinger,
|
||||
"input",
|
||||
"touch_get_finger",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetUp,
|
||||
"input",
|
||||
"pad_get_up",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetDown,
|
||||
"input",
|
||||
"pad_get_down",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetLeft,
|
||||
"input",
|
||||
"pad_get_left",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetRight,
|
||||
"input",
|
||||
"pad_get_right",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetA,
|
||||
"input",
|
||||
"pad_get_a",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetB,
|
||||
"input",
|
||||
"pad_get_b",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetX,
|
||||
"input",
|
||||
"pad_get_x",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetY,
|
||||
"input",
|
||||
"pad_get_y",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetL,
|
||||
"input",
|
||||
"pad_get_l",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetR,
|
||||
"input",
|
||||
"pad_get_r",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetStart,
|
||||
"input",
|
||||
"pad_get_start",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
entry(
|
||||
Syscall::PadGetSelect,
|
||||
"input",
|
||||
"pad_get_select",
|
||||
1,
|
||||
0,
|
||||
4,
|
||||
caps::INPUT,
|
||||
Determinism::Deterministic,
|
||||
false,
|
||||
1,
|
||||
),
|
||||
];
|
||||
@@ -3,7 +3,6 @@ mod audio;
|
||||
mod bank;
|
||||
mod fs;
|
||||
mod gfx;
|
||||
mod input;
|
||||
mod log;
|
||||
mod system;
|
||||
|
||||
@@ -42,7 +41,6 @@ pub(crate) fn all_entries() -> impl Iterator<Item = &'static SyscallRegistryEntr
|
||||
system::ENTRIES
|
||||
.iter()
|
||||
.chain(gfx::ENTRIES.iter())
|
||||
.chain(input::ENTRIES.iter())
|
||||
.chain(audio::ENTRIES.iter())
|
||||
.chain(fs::ENTRIES.iter())
|
||||
.chain(log::ENTRIES.iter())
|
||||
|
||||
@@ -23,31 +23,6 @@ impl Syscall {
|
||||
0x1007 => Some(Self::GfxSetSprite),
|
||||
0x1008 => Some(Self::GfxDrawText),
|
||||
0x1010 => Some(Self::GfxClear565),
|
||||
0x2001 => Some(Self::InputGetPad),
|
||||
0x2002 => Some(Self::InputGetPadPressed),
|
||||
0x2003 => Some(Self::InputGetPadReleased),
|
||||
0x2004 => Some(Self::InputGetPadHold),
|
||||
0x2010 => Some(Self::InputPadSnapshot),
|
||||
0x2011 => Some(Self::InputTouchSnapshot),
|
||||
0x2101 => Some(Self::TouchGetX),
|
||||
0x2102 => Some(Self::TouchGetY),
|
||||
0x2103 => Some(Self::TouchIsDown),
|
||||
0x2104 => Some(Self::TouchIsPressed),
|
||||
0x2105 => Some(Self::TouchIsReleased),
|
||||
0x2106 => Some(Self::TouchGetHold),
|
||||
0x2107 => Some(Self::TouchGetFinger),
|
||||
0x2200 => Some(Self::PadGetUp),
|
||||
0x2201 => Some(Self::PadGetDown),
|
||||
0x2202 => Some(Self::PadGetLeft),
|
||||
0x2203 => Some(Self::PadGetRight),
|
||||
0x2204 => Some(Self::PadGetA),
|
||||
0x2205 => Some(Self::PadGetB),
|
||||
0x2206 => Some(Self::PadGetX),
|
||||
0x2207 => Some(Self::PadGetY),
|
||||
0x2208 => Some(Self::PadGetL),
|
||||
0x2209 => Some(Self::PadGetR),
|
||||
0x220A => Some(Self::PadGetStart),
|
||||
0x220B => Some(Self::PadGetSelect),
|
||||
0x3001 => Some(Self::AudioPlaySample),
|
||||
0x3002 => Some(Self::AudioPlay),
|
||||
0x4001 => Some(Self::FsOpen),
|
||||
@@ -90,31 +65,6 @@ impl Syscall {
|
||||
Self::GfxSetSprite => "GfxSetSprite",
|
||||
Self::GfxDrawText => "GfxDrawText",
|
||||
Self::GfxClear565 => "GfxClear565",
|
||||
Self::InputGetPad => "InputGetPad",
|
||||
Self::InputGetPadPressed => "InputGetPadPressed",
|
||||
Self::InputGetPadReleased => "InputGetPadReleased",
|
||||
Self::InputGetPadHold => "InputGetPadHold",
|
||||
Self::InputPadSnapshot => "InputPadSnapshot",
|
||||
Self::InputTouchSnapshot => "InputTouchSnapshot",
|
||||
Self::TouchGetX => "TouchGetX",
|
||||
Self::TouchGetY => "TouchGetY",
|
||||
Self::TouchIsDown => "TouchIsDown",
|
||||
Self::TouchIsPressed => "TouchIsPressed",
|
||||
Self::TouchIsReleased => "TouchIsReleased",
|
||||
Self::TouchGetHold => "TouchGetHold",
|
||||
Self::TouchGetFinger => "TouchGetFinger",
|
||||
Self::PadGetUp => "PadGetUp",
|
||||
Self::PadGetDown => "PadGetDown",
|
||||
Self::PadGetLeft => "PadGetLeft",
|
||||
Self::PadGetRight => "PadGetRight",
|
||||
Self::PadGetA => "PadGetA",
|
||||
Self::PadGetB => "PadGetB",
|
||||
Self::PadGetX => "PadGetX",
|
||||
Self::PadGetY => "PadGetY",
|
||||
Self::PadGetL => "PadGetL",
|
||||
Self::PadGetR => "PadGetR",
|
||||
Self::PadGetStart => "PadGetStart",
|
||||
Self::PadGetSelect => "PadGetSelect",
|
||||
Self::AudioPlaySample => "AudioPlaySample",
|
||||
Self::AudioPlay => "AudioPlay",
|
||||
Self::FsOpen => "FsOpen",
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
use super::*;
|
||||
use prometeu_bytecode::{TRAP_INVALID_SYSCALL, TRAP_OOB, TRAP_TYPE, Value};
|
||||
use prometeu_hal::asset::{BankType, LoadStatus, SlotRef};
|
||||
use prometeu_hal::button::Button;
|
||||
use prometeu_hal::color::Color;
|
||||
use prometeu_hal::log::{LogLevel, LogSource};
|
||||
use prometeu_hal::sprite::Sprite;
|
||||
@@ -51,51 +50,6 @@ impl VirtualMachineRuntime {
|
||||
pub(crate) fn get_color(&self, value: i64) -> Color {
|
||||
Color::from_raw(value as u16)
|
||||
}
|
||||
|
||||
pub(crate) fn get_button<'a>(
|
||||
&self,
|
||||
id: u32,
|
||||
hw: &'a dyn prometeu_hal::HardwareBridge,
|
||||
) -> Option<&'a Button> {
|
||||
let pad = hw.pad();
|
||||
match id {
|
||||
0 => Some(pad.up()),
|
||||
1 => Some(pad.down()),
|
||||
2 => Some(pad.left()),
|
||||
3 => Some(pad.right()),
|
||||
4 => Some(pad.a()),
|
||||
5 => Some(pad.b()),
|
||||
6 => Some(pad.x()),
|
||||
7 => Some(pad.y()),
|
||||
8 => Some(pad.l()),
|
||||
9 => Some(pad.r()),
|
||||
10 => Some(pad.start()),
|
||||
11 => Some(pad.select()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_button_down(
|
||||
&self,
|
||||
id: u32,
|
||||
hw: &mut dyn prometeu_hal::HardwareBridge,
|
||||
) -> bool {
|
||||
match id {
|
||||
0 => hw.pad().up().down,
|
||||
1 => hw.pad().down().down,
|
||||
2 => hw.pad().left().down,
|
||||
3 => hw.pad().right().down,
|
||||
4 => hw.pad().a().down,
|
||||
5 => hw.pad().b().down,
|
||||
6 => hw.pad().x().down,
|
||||
7 => hw.pad().y().down,
|
||||
8 => hw.pad().l().down,
|
||||
9 => hw.pad().r().down,
|
||||
10 => hw.pad().start().down,
|
||||
11 => hw.pad().select().down,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl NativeInterface for VirtualMachineRuntime {
|
||||
@@ -232,111 +186,6 @@ impl NativeInterface for VirtualMachineRuntime {
|
||||
hw.gfx_mut().clear(Color::from_raw(color_val as u16));
|
||||
Ok(())
|
||||
}
|
||||
Syscall::InputGetPad => {
|
||||
ret.push_bool(self.is_button_down(expect_int(args, 0)? as u32, hw));
|
||||
Ok(())
|
||||
}
|
||||
Syscall::InputGetPadPressed => {
|
||||
let val = self
|
||||
.get_button(expect_int(args, 0)? as u32, hw)
|
||||
.map(|b| b.pressed)
|
||||
.unwrap_or(false);
|
||||
ret.push_bool(val);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::InputGetPadReleased => {
|
||||
let val = self
|
||||
.get_button(expect_int(args, 0)? as u32, hw)
|
||||
.map(|b| b.released)
|
||||
.unwrap_or(false);
|
||||
ret.push_bool(val);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::InputGetPadHold => {
|
||||
let val = self
|
||||
.get_button(expect_int(args, 0)? as u32, hw)
|
||||
.map(|b| b.hold_frames)
|
||||
.unwrap_or(0);
|
||||
ret.push_int(val as i64);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchGetX => {
|
||||
ret.push_int(hw.touch().x() as i64);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchGetY => {
|
||||
ret.push_int(hw.touch().y() as i64);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchIsDown => {
|
||||
ret.push_bool(hw.touch().f().down);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchIsPressed => {
|
||||
ret.push_bool(hw.touch().f().pressed);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchIsReleased => {
|
||||
ret.push_bool(hw.touch().f().released);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchGetHold => {
|
||||
ret.push_int(hw.touch().f().hold_frames as i64);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::TouchGetFinger => {
|
||||
let btn = hw.touch().f();
|
||||
ret.push_bool(btn.pressed);
|
||||
ret.push_bool(btn.released);
|
||||
ret.push_bool(btn.down);
|
||||
ret.push_int(btn.hold_frames as i64);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::InputPadSnapshot => {
|
||||
let pad = hw.pad();
|
||||
for btn in [
|
||||
pad.up(),
|
||||
pad.down(),
|
||||
pad.left(),
|
||||
pad.right(),
|
||||
pad.a(),
|
||||
pad.b(),
|
||||
pad.x(),
|
||||
pad.y(),
|
||||
pad.l(),
|
||||
pad.r(),
|
||||
pad.start(),
|
||||
pad.select(),
|
||||
] {
|
||||
ret.push_bool(btn.pressed);
|
||||
ret.push_bool(btn.released);
|
||||
ret.push_bool(btn.down);
|
||||
ret.push_int(btn.hold_frames as i64);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
Syscall::InputTouchSnapshot => {
|
||||
let touch = hw.touch();
|
||||
ret.push_bool(touch.f().pressed);
|
||||
ret.push_bool(touch.f().released);
|
||||
ret.push_bool(touch.f().down);
|
||||
ret.push_int(touch.f().hold_frames as i64);
|
||||
ret.push_int(touch.x() as i64);
|
||||
ret.push_int(touch.y() as i64);
|
||||
Ok(())
|
||||
}
|
||||
Syscall::PadGetUp => push_button(ret, hw.pad().up()),
|
||||
Syscall::PadGetDown => push_button(ret, hw.pad().down()),
|
||||
Syscall::PadGetLeft => push_button(ret, hw.pad().left()),
|
||||
Syscall::PadGetRight => push_button(ret, hw.pad().right()),
|
||||
Syscall::PadGetA => push_button(ret, hw.pad().a()),
|
||||
Syscall::PadGetB => push_button(ret, hw.pad().b()),
|
||||
Syscall::PadGetX => push_button(ret, hw.pad().x()),
|
||||
Syscall::PadGetY => push_button(ret, hw.pad().y()),
|
||||
Syscall::PadGetL => push_button(ret, hw.pad().l()),
|
||||
Syscall::PadGetR => push_button(ret, hw.pad().r()),
|
||||
Syscall::PadGetStart => push_button(ret, hw.pad().start()),
|
||||
Syscall::PadGetSelect => push_button(ret, hw.pad().select()),
|
||||
Syscall::AudioPlaySample => {
|
||||
let sample_id = expect_int(args, 0)? as u32;
|
||||
let voice_id = expect_int(args, 1)? as usize;
|
||||
@@ -521,14 +370,6 @@ impl NativeInterface for VirtualMachineRuntime {
|
||||
}
|
||||
}
|
||||
|
||||
fn push_button(ret: &mut HostReturn, button: &Button) -> Result<(), VmFault> {
|
||||
ret.push_bool(button.pressed);
|
||||
ret.push_bool(button.released);
|
||||
ret.push_bool(button.down);
|
||||
ret.push_int(button.hold_frames as i64);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn expect_string(args: &[Value], index: usize, field: &str) -> Result<String, VmFault> {
|
||||
match args.get(index).ok_or_else(|| VmFault::Panic(format!("Missing {}", field)))? {
|
||||
Value::String(value) => Ok(value.clone()),
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
use prometeu_bytecode::Value;
|
||||
use prometeu_hal::HostContext;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct BuiltinTypeKey {
|
||||
@@ -176,6 +177,8 @@ impl BuiltinConstMeta {
|
||||
pub enum IntrinsicExecutionError {
|
||||
ArityMismatch { expected: usize, got: usize },
|
||||
TypeMismatch { index: usize, expected: AbiType },
|
||||
InvalidBuiltinCarrier { owner: &'static str, name: &'static str, carrier: i64 },
|
||||
HardwareUnavailable,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
@@ -184,7 +187,8 @@ pub enum BuiltinValueError {
|
||||
TypeMismatch { index: usize, expected: AbiType },
|
||||
}
|
||||
|
||||
pub type IntrinsicImplementation = fn(&[Value]) -> Result<Vec<Value>, IntrinsicExecutionError>;
|
||||
pub type IntrinsicImplementation =
|
||||
fn(&[Value], &mut HostContext<'_>) -> Result<Vec<Value>, IntrinsicExecutionError>;
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct IntrinsicMeta {
|
||||
@@ -245,6 +249,9 @@ impl BuiltinConstSlotValue {
|
||||
const COLOR: BuiltinTypeKey = BuiltinTypeKey::new("color", 1);
|
||||
const VEC2: BuiltinTypeKey = BuiltinTypeKey::new("vec2", 1);
|
||||
const PIXEL: BuiltinTypeKey = BuiltinTypeKey::new("pixel", 1);
|
||||
const INPUT_PAD: BuiltinTypeKey = BuiltinTypeKey::new("input.pad", 1);
|
||||
const INPUT_TOUCH: BuiltinTypeKey = BuiltinTypeKey::new("input.touch", 1);
|
||||
const INPUT_BUTTON: BuiltinTypeKey = BuiltinTypeKey::new("input.button", 1);
|
||||
|
||||
const COLOR_LAYOUT: [AbiType; 1] = [AbiType::Builtin(COLOR)];
|
||||
const VEC2_LAYOUT: [AbiType; 2] =
|
||||
@@ -254,6 +261,9 @@ const PIXEL_LAYOUT: [AbiType; 3] = [
|
||||
AbiType::Scalar(BuiltinScalarType::Int),
|
||||
AbiType::Builtin(COLOR),
|
||||
];
|
||||
const INPUT_PAD_LAYOUT: [AbiType; 1] = [AbiType::Builtin(INPUT_PAD)];
|
||||
const INPUT_TOUCH_LAYOUT: [AbiType; 1] = [AbiType::Builtin(INPUT_TOUCH)];
|
||||
const INPUT_BUTTON_LAYOUT: [AbiType; 1] = [AbiType::Builtin(INPUT_BUTTON)];
|
||||
|
||||
const VEC2_FIELDS: [BuiltinFieldMeta; 2] = [
|
||||
BuiltinFieldMeta {
|
||||
@@ -291,7 +301,7 @@ const PIXEL_FIELDS: [BuiltinFieldMeta; 3] = [
|
||||
},
|
||||
];
|
||||
|
||||
const BUILTIN_TYPES: [BuiltinTypeMeta; 3] = [
|
||||
const BUILTIN_TYPES: [BuiltinTypeMeta; 6] = [
|
||||
BuiltinTypeMeta {
|
||||
id: 0x0001,
|
||||
name: COLOR.name,
|
||||
@@ -319,6 +329,33 @@ const BUILTIN_TYPES: [BuiltinTypeMeta; 3] = [
|
||||
flat_slot_layout: &PIXEL_LAYOUT,
|
||||
flat_slot_width: 3,
|
||||
},
|
||||
BuiltinTypeMeta {
|
||||
id: 0x0100,
|
||||
name: INPUT_PAD.name,
|
||||
version: INPUT_PAD.version,
|
||||
shape: BuiltinTypeShape::Scalar,
|
||||
fields: &[],
|
||||
flat_slot_layout: &INPUT_PAD_LAYOUT,
|
||||
flat_slot_width: 1,
|
||||
},
|
||||
BuiltinTypeMeta {
|
||||
id: 0x0101,
|
||||
name: INPUT_TOUCH.name,
|
||||
version: INPUT_TOUCH.version,
|
||||
shape: BuiltinTypeShape::Scalar,
|
||||
fields: &[],
|
||||
flat_slot_layout: &INPUT_TOUCH_LAYOUT,
|
||||
flat_slot_width: 1,
|
||||
},
|
||||
BuiltinTypeMeta {
|
||||
id: 0x0102,
|
||||
name: INPUT_BUTTON.name,
|
||||
version: INPUT_BUTTON.version,
|
||||
shape: BuiltinTypeShape::Scalar,
|
||||
fields: &[],
|
||||
flat_slot_layout: &INPUT_BUTTON_LAYOUT,
|
||||
flat_slot_width: 1,
|
||||
},
|
||||
];
|
||||
|
||||
const VEC2_ZERO_LAYOUT: [AbiType; 2] =
|
||||
@@ -341,7 +378,17 @@ const VEC2_DOT_ARGS: [AbiType; 4] = [
|
||||
const SINGLE_FLOAT_RET: [AbiType; 1] = [AbiType::Scalar(BuiltinScalarType::Float)];
|
||||
const VEC2_LENGTH_ARGS: [AbiType; 2] =
|
||||
[AbiType::Scalar(BuiltinScalarType::Float), AbiType::Scalar(BuiltinScalarType::Float)];
|
||||
const INTRINSICS: [IntrinsicMeta; 2] = [
|
||||
const NO_ARGS: [AbiType; 0] = [];
|
||||
const PAD_RET: [AbiType; 1] = [AbiType::Builtin(INPUT_PAD)];
|
||||
const TOUCH_RET: [AbiType; 1] = [AbiType::Builtin(INPUT_TOUCH)];
|
||||
const BUTTON_RET: [AbiType; 1] = [AbiType::Builtin(INPUT_BUTTON)];
|
||||
const PAD_ARGS: [AbiType; 1] = [AbiType::Builtin(INPUT_PAD)];
|
||||
const TOUCH_ARGS: [AbiType; 1] = [AbiType::Builtin(INPUT_TOUCH)];
|
||||
const BUTTON_ARGS: [AbiType; 1] = [AbiType::Builtin(INPUT_BUTTON)];
|
||||
const BOOL_RET: [AbiType; 1] = [AbiType::Scalar(BuiltinScalarType::Bool)];
|
||||
const INT_RET: [AbiType; 1] = [AbiType::Scalar(BuiltinScalarType::Int)];
|
||||
|
||||
const INTRINSICS: [IntrinsicMeta; 23] = [
|
||||
IntrinsicMeta {
|
||||
id: 0x1000,
|
||||
owner: "vec2",
|
||||
@@ -364,6 +411,237 @@ const INTRINSICS: [IntrinsicMeta; 2] = [
|
||||
may_allocate: false,
|
||||
implementation: vec2_length,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2000,
|
||||
owner: "input",
|
||||
name: "pad",
|
||||
version: 1,
|
||||
arg_layout: &NO_ARGS,
|
||||
ret_layout: &PAD_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2001,
|
||||
owner: "input",
|
||||
name: "touch",
|
||||
version: 1,
|
||||
arg_layout: &NO_ARGS,
|
||||
ret_layout: &TOUCH_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_touch,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2010,
|
||||
owner: "input.pad",
|
||||
name: "up",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_up,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2011,
|
||||
owner: "input.pad",
|
||||
name: "down",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_down,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2012,
|
||||
owner: "input.pad",
|
||||
name: "left",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_left,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2013,
|
||||
owner: "input.pad",
|
||||
name: "right",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_right,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2014,
|
||||
owner: "input.pad",
|
||||
name: "a",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_a,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2015,
|
||||
owner: "input.pad",
|
||||
name: "b",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_b,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2016,
|
||||
owner: "input.pad",
|
||||
name: "x",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_x,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2017,
|
||||
owner: "input.pad",
|
||||
name: "y",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_y,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2018,
|
||||
owner: "input.pad",
|
||||
name: "l",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_l,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2019,
|
||||
owner: "input.pad",
|
||||
name: "r",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_r,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x201A,
|
||||
owner: "input.pad",
|
||||
name: "start",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_start,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x201B,
|
||||
owner: "input.pad",
|
||||
name: "select",
|
||||
version: 1,
|
||||
arg_layout: &PAD_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_pad_select,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2020,
|
||||
owner: "input.touch",
|
||||
name: "button",
|
||||
version: 1,
|
||||
arg_layout: &TOUCH_ARGS,
|
||||
ret_layout: &BUTTON_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_touch_button,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2021,
|
||||
owner: "input.touch",
|
||||
name: "x",
|
||||
version: 1,
|
||||
arg_layout: &TOUCH_ARGS,
|
||||
ret_layout: &INT_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_touch_x,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2022,
|
||||
owner: "input.touch",
|
||||
name: "y",
|
||||
version: 1,
|
||||
arg_layout: &TOUCH_ARGS,
|
||||
ret_layout: &INT_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_touch_y,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2030,
|
||||
owner: "input.button",
|
||||
name: "pressed",
|
||||
version: 1,
|
||||
arg_layout: &BUTTON_ARGS,
|
||||
ret_layout: &BOOL_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_button_pressed,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2031,
|
||||
owner: "input.button",
|
||||
name: "released",
|
||||
version: 1,
|
||||
arg_layout: &BUTTON_ARGS,
|
||||
ret_layout: &BOOL_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_button_released,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2032,
|
||||
owner: "input.button",
|
||||
name: "down",
|
||||
version: 1,
|
||||
arg_layout: &BUTTON_ARGS,
|
||||
ret_layout: &BOOL_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_button_down,
|
||||
},
|
||||
IntrinsicMeta {
|
||||
id: 0x2033,
|
||||
owner: "input.button",
|
||||
name: "hold",
|
||||
version: 1,
|
||||
arg_layout: &BUTTON_ARGS,
|
||||
ret_layout: &INT_RET,
|
||||
deterministic: true,
|
||||
may_allocate: false,
|
||||
implementation: input_button_hold,
|
||||
},
|
||||
];
|
||||
|
||||
pub fn lookup_builtin_type(name: &str, version: u16) -> Option<&'static BuiltinTypeMeta> {
|
||||
@@ -446,7 +724,15 @@ fn validate_values_against_layout(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn vec2_dot(args: &[Value]) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
const PAD_HANDLE: i64 = 1;
|
||||
const TOUCH_HANDLE: i64 = 1;
|
||||
const PAD_BUTTON_BASE: i64 = 0x100;
|
||||
const TOUCH_BUTTON_CARRIER: i64 = 0x200;
|
||||
|
||||
fn vec2_dot(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
if args.len() != 4 {
|
||||
return Err(IntrinsicExecutionError::ArityMismatch { expected: 4, got: args.len() });
|
||||
}
|
||||
@@ -457,7 +743,10 @@ fn vec2_dot(args: &[Value]) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
Ok(vec![Value::Float((ax * bx) + (ay * by))])
|
||||
}
|
||||
|
||||
fn vec2_length(args: &[Value]) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
fn vec2_length(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
if args.len() != 2 {
|
||||
return Err(IntrinsicExecutionError::ArityMismatch { expected: 2, got: args.len() });
|
||||
}
|
||||
@@ -466,6 +755,250 @@ fn vec2_length(args: &[Value]) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
Ok(vec![Value::Float((x * x + y * y).sqrt())])
|
||||
}
|
||||
|
||||
fn input_pad(
|
||||
_args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
Ok(vec![Value::Int64(PAD_HANDLE)])
|
||||
}
|
||||
|
||||
fn input_touch(
|
||||
_args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
Ok(vec![Value::Int64(TOUCH_HANDLE)])
|
||||
}
|
||||
|
||||
fn input_pad_up(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "up")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE)])
|
||||
}
|
||||
|
||||
fn input_pad_down(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "down")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 1)])
|
||||
}
|
||||
|
||||
fn input_pad_left(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "left")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 2)])
|
||||
}
|
||||
|
||||
fn input_pad_right(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "right")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 3)])
|
||||
}
|
||||
|
||||
fn input_pad_a(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "a")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 4)])
|
||||
}
|
||||
|
||||
fn input_pad_b(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "b")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 5)])
|
||||
}
|
||||
|
||||
fn input_pad_x(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "x")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 6)])
|
||||
}
|
||||
|
||||
fn input_pad_y(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "y")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 7)])
|
||||
}
|
||||
|
||||
fn input_pad_l(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "l")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 8)])
|
||||
}
|
||||
|
||||
fn input_pad_r(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "r")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 9)])
|
||||
}
|
||||
|
||||
fn input_pad_start(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "start")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 10)])
|
||||
}
|
||||
|
||||
fn input_pad_select(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_pad_handle(args, "select")?;
|
||||
Ok(vec![Value::Int64(PAD_BUTTON_BASE + 11)])
|
||||
}
|
||||
|
||||
fn input_touch_button(
|
||||
args: &[Value],
|
||||
_ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_touch_handle(args, "button")?;
|
||||
Ok(vec![Value::Int64(TOUCH_BUTTON_CARRIER)])
|
||||
}
|
||||
|
||||
fn input_touch_x(
|
||||
args: &[Value],
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_touch_handle(args, "x")?;
|
||||
let hw = ctx.require_hw().map_err(|_| IntrinsicExecutionError::HardwareUnavailable)?;
|
||||
Ok(vec![Value::Int64(hw.touch().x() as i64)])
|
||||
}
|
||||
|
||||
fn input_touch_y(
|
||||
args: &[Value],
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
expect_touch_handle(args, "y")?;
|
||||
let hw = ctx.require_hw().map_err(|_| IntrinsicExecutionError::HardwareUnavailable)?;
|
||||
Ok(vec![Value::Int64(hw.touch().y() as i64)])
|
||||
}
|
||||
|
||||
fn input_button_pressed(
|
||||
args: &[Value],
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
let button = resolve_button(args, "pressed", ctx)?;
|
||||
Ok(vec![Value::Boolean(button.pressed)])
|
||||
}
|
||||
|
||||
fn input_button_released(
|
||||
args: &[Value],
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
let button = resolve_button(args, "released", ctx)?;
|
||||
Ok(vec![Value::Boolean(button.released)])
|
||||
}
|
||||
|
||||
fn input_button_down(
|
||||
args: &[Value],
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
let button = resolve_button(args, "down", ctx)?;
|
||||
Ok(vec![Value::Boolean(button.down)])
|
||||
}
|
||||
|
||||
fn input_button_hold(
|
||||
args: &[Value],
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<Vec<Value>, IntrinsicExecutionError> {
|
||||
let button = resolve_button(args, "hold", ctx)?;
|
||||
Ok(vec![Value::Int64(button.hold_frames as i64)])
|
||||
}
|
||||
|
||||
fn expect_pad_handle(args: &[Value], name: &'static str) -> Result<(), IntrinsicExecutionError> {
|
||||
let carrier = expect_builtin_carrier(args, 0)?;
|
||||
if carrier != PAD_HANDLE {
|
||||
return Err(IntrinsicExecutionError::InvalidBuiltinCarrier {
|
||||
owner: "input.pad",
|
||||
name,
|
||||
carrier,
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn expect_touch_handle(args: &[Value], name: &'static str) -> Result<(), IntrinsicExecutionError> {
|
||||
let carrier = expect_builtin_carrier(args, 0)?;
|
||||
if carrier != TOUCH_HANDLE {
|
||||
return Err(IntrinsicExecutionError::InvalidBuiltinCarrier {
|
||||
owner: "input.touch",
|
||||
name,
|
||||
carrier,
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn expect_builtin_carrier(args: &[Value], index: usize) -> Result<i64, IntrinsicExecutionError> {
|
||||
let value = args
|
||||
.get(index)
|
||||
.ok_or(IntrinsicExecutionError::ArityMismatch { expected: index + 1, got: args.len() })?;
|
||||
value.as_integer().ok_or(IntrinsicExecutionError::TypeMismatch {
|
||||
index,
|
||||
expected: AbiType::Scalar(BuiltinScalarType::Int),
|
||||
})
|
||||
}
|
||||
|
||||
fn resolve_button(
|
||||
args: &[Value],
|
||||
name: &'static str,
|
||||
ctx: &mut HostContext<'_>,
|
||||
) -> Result<prometeu_hal::button::Button, IntrinsicExecutionError> {
|
||||
let carrier = expect_builtin_carrier(args, 0)?;
|
||||
let hw = ctx.require_hw().map_err(|_| IntrinsicExecutionError::HardwareUnavailable)?;
|
||||
if carrier == TOUCH_BUTTON_CARRIER {
|
||||
return Ok(*hw.touch().f());
|
||||
}
|
||||
|
||||
let Some(index) = carrier.checked_sub(PAD_BUTTON_BASE) else {
|
||||
return Err(IntrinsicExecutionError::InvalidBuiltinCarrier {
|
||||
owner: "input.button",
|
||||
name,
|
||||
carrier,
|
||||
});
|
||||
};
|
||||
let button = match index {
|
||||
0 => *hw.pad().up(),
|
||||
1 => *hw.pad().down(),
|
||||
2 => *hw.pad().left(),
|
||||
3 => *hw.pad().right(),
|
||||
4 => *hw.pad().a(),
|
||||
5 => *hw.pad().b(),
|
||||
6 => *hw.pad().x(),
|
||||
7 => *hw.pad().y(),
|
||||
8 => *hw.pad().l(),
|
||||
9 => *hw.pad().r(),
|
||||
10 => *hw.pad().start(),
|
||||
11 => *hw.pad().select(),
|
||||
_ => {
|
||||
return Err(IntrinsicExecutionError::InvalidBuiltinCarrier {
|
||||
owner: "input.button",
|
||||
name,
|
||||
carrier,
|
||||
});
|
||||
}
|
||||
};
|
||||
Ok(button)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -546,26 +1079,41 @@ mod tests {
|
||||
assert_eq!(length.arg_layout.len(), 2);
|
||||
assert_eq!(length.ret_layout.len(), 1);
|
||||
assert_eq!(lookup_intrinsic_by_id(length.id).map(|meta| meta.key()), Some(length.key()));
|
||||
|
||||
let hold =
|
||||
lookup_intrinsic("input.button", "hold", 1).expect("input.button.hold must exist");
|
||||
assert_eq!(hold.arg_layout.len(), 1);
|
||||
assert_eq!(hold.ret_layout.len(), 1);
|
||||
assert!(hold.deterministic);
|
||||
assert!(!hold.may_allocate);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intrinsic_implementations_are_registered_without_syscalls() {
|
||||
let dot = lookup_intrinsic("vec2", "dot", 1).expect("vec2.dot must exist");
|
||||
let result = (dot.implementation)(&[
|
||||
Value::Float(1.0),
|
||||
Value::Float(2.0),
|
||||
Value::Float(3.0),
|
||||
Value::Float(4.0),
|
||||
])
|
||||
let mut ctx = HostContext::new(None);
|
||||
let result = (dot.implementation)(
|
||||
&[Value::Float(1.0), Value::Float(2.0), Value::Float(3.0), Value::Float(4.0)],
|
||||
&mut ctx,
|
||||
)
|
||||
.expect("dot implementation must execute");
|
||||
assert_eq!(result, vec![Value::Float(11.0)]);
|
||||
|
||||
let length = lookup_intrinsic("vec2", "length", 1).expect("vec2.length must exist");
|
||||
let result = (length.implementation)(&[Value::Float(3.0), Value::Float(4.0)])
|
||||
let result = (length.implementation)(&[Value::Float(3.0), Value::Float(4.0)], &mut ctx)
|
||||
.expect("length implementation must execute");
|
||||
assert_eq!(result, vec![Value::Float(5.0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn input_intrinsic_requires_hardware_context() {
|
||||
let mut ctx = HostContext::new(None);
|
||||
let touch_x = lookup_intrinsic("input.touch", "x", 1).expect("input.touch.x must exist");
|
||||
let err = (touch_x.implementation)(&[Value::Int64(TOUCH_HANDLE)], &mut ctx)
|
||||
.expect_err("touch.x must fail without hardware context");
|
||||
assert_eq!(err, IntrinsicExecutionError::HardwareUnavailable);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pixel_flat_values_validate_with_color_carrier_slot() {
|
||||
let pixel = lookup_builtin_type("pixel", 1).expect("pixel builtin must exist");
|
||||
|
||||
@@ -1111,7 +1111,7 @@ impl VirtualMachine {
|
||||
}
|
||||
args.reverse();
|
||||
|
||||
let results = (intrinsic.implementation)(&args).map_err(|err| match err {
|
||||
let results = (intrinsic.implementation)(&args, ctx).map_err(|err| match err {
|
||||
crate::IntrinsicExecutionError::ArityMismatch { expected, got } => self.trap(
|
||||
TRAP_INVALID_INTRINSIC,
|
||||
OpCode::Intrinsic as u16,
|
||||
@@ -1130,6 +1130,22 @@ impl VirtualMachine {
|
||||
),
|
||||
pc_at_intrinsic,
|
||||
),
|
||||
crate::IntrinsicExecutionError::InvalidBuiltinCarrier {
|
||||
owner,
|
||||
name,
|
||||
carrier,
|
||||
} => self.trap(
|
||||
TRAP_INVALID_INTRINSIC,
|
||||
OpCode::Intrinsic as u16,
|
||||
format!(
|
||||
"Intrinsic {}.{} received invalid builtin carrier {} for {}.{}",
|
||||
intrinsic.owner, intrinsic.name, carrier, owner, name
|
||||
),
|
||||
pc_at_intrinsic,
|
||||
),
|
||||
crate::IntrinsicExecutionError::HardwareUnavailable => {
|
||||
LogicalFrameEndingReason::Panic("Host feature unavailable".into())
|
||||
}
|
||||
})?;
|
||||
|
||||
intrinsic.validate_result_values(&results).map_err(|err| match err {
|
||||
@@ -1151,6 +1167,24 @@ impl VirtualMachine {
|
||||
),
|
||||
pc_at_intrinsic,
|
||||
),
|
||||
crate::IntrinsicExecutionError::InvalidBuiltinCarrier {
|
||||
owner,
|
||||
name,
|
||||
carrier,
|
||||
} => self.trap(
|
||||
TRAP_INVALID_INTRINSIC,
|
||||
OpCode::Intrinsic as u16,
|
||||
format!(
|
||||
"Intrinsic {}.{} produced invalid builtin carrier {} for {}.{}",
|
||||
intrinsic.owner, intrinsic.name, carrier, owner, name
|
||||
),
|
||||
pc_at_intrinsic,
|
||||
),
|
||||
crate::IntrinsicExecutionError::HardwareUnavailable => {
|
||||
LogicalFrameEndingReason::Panic(
|
||||
"Host feature unavailable while validating intrinsic results".into(),
|
||||
)
|
||||
}
|
||||
})?;
|
||||
|
||||
for value in results {
|
||||
@@ -2331,6 +2365,34 @@ mod tests {
|
||||
assert_eq!(vm.operand_stack, vec![Value::Float(5.0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_intrinsic_input_pad_returns_builtin_carrier() {
|
||||
let rom = assemble("INTRINSIC 0x2000\nHALT").expect("assemble");
|
||||
let mut vm = new_test_vm(rom, vec![]);
|
||||
let mut native = MockNative;
|
||||
let mut ctx = HostContext::new(None);
|
||||
|
||||
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Halted));
|
||||
assert_eq!(vm.operand_stack, vec![Value::Int64(1)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_intrinsic_input_touch_x_requires_hardware_context() {
|
||||
let rom = assemble("INTRINSIC 0x2001\nINTRINSIC 0x2021\nHALT").expect("assemble");
|
||||
let mut vm = new_test_vm(rom, vec![]);
|
||||
let mut native = MockNative;
|
||||
let mut ctx = HostContext::new(None);
|
||||
|
||||
let report = vm.run_budget(100, &mut native, &mut ctx).unwrap();
|
||||
match report.reason {
|
||||
LogicalFrameEndingReason::Panic(msg) => {
|
||||
assert!(msg.contains("Host feature unavailable"));
|
||||
}
|
||||
other => panic!("Expected Panic due to missing hardware context, got {:?}", other),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_invalid_intrinsic_trap_is_distinct_from_syscall() {
|
||||
let rom = assemble("INTRINSIC 0xDEADBEEF\nHALT").expect("assemble");
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
//! Regression test: input is no longer exposed through the syscall registry.
|
||||
use prometeu_bytecode::isa::core::CoreOpCode as OpCode;
|
||||
use prometeu_hal::vm_fault::VmFault;
|
||||
use prometeu_vm::{HostContext, HostReturn, NativeInterface, VirtualMachine};
|
||||
|
||||
fn enc_op(op: OpCode) -> [u8; 2] {
|
||||
(op as u16).to_le_bytes()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vm_rejects_legacy_input_syscall_id() {
|
||||
// Legacy input syscall id (PadGetUp) must now be rejected as unknown syscall.
|
||||
let mut rom = Vec::new();
|
||||
rom.extend_from_slice(&enc_op(OpCode::Syscall));
|
||||
rom.extend_from_slice(&0x2200u32.to_le_bytes());
|
||||
rom.extend_from_slice(&enc_op(OpCode::Halt));
|
||||
|
||||
struct NoopNative;
|
||||
impl NativeInterface for NoopNative {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
_id: u32,
|
||||
_args: &[prometeu_bytecode::Value],
|
||||
_ret: &mut HostReturn,
|
||||
_ctx: &mut HostContext,
|
||||
) -> Result<(), VmFault> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
let mut vm = VirtualMachine::new(rom, vec![]);
|
||||
let mut native = NoopNative;
|
||||
let mut ctx = HostContext::new(None);
|
||||
vm.prepare_call("0");
|
||||
vm.set_capabilities(prometeu_hal::syscalls::caps::ALL);
|
||||
|
||||
let report = vm.run_budget(100, &mut native, &mut ctx).expect("VM run failed");
|
||||
match report.reason {
|
||||
prometeu_vm::LogicalFrameEndingReason::Trap(trap) => {
|
||||
assert_eq!(trap.code, prometeu_bytecode::TRAP_INVALID_SYSCALL);
|
||||
assert!(trap.message.contains("Unknown syscall"));
|
||||
}
|
||||
other => panic!("Expected invalid syscall trap, got {:?}", other),
|
||||
}
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
//! Deterministic tests for multi-return syscalls with the slot-based ABI.
|
||||
use prometeu_bytecode::Value;
|
||||
use prometeu_bytecode::isa::core::CoreOpCode as OpCode;
|
||||
use prometeu_hal::vm_fault::VmFault;
|
||||
use prometeu_vm::{HostContext, HostReturn, NativeInterface, VirtualMachine};
|
||||
|
||||
fn enc_op(op: OpCode) -> [u8; 2] {
|
||||
(op as u16).to_le_bytes()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vm_syscall_multi_return_stack_contents() {
|
||||
// Use a real multi-return syscall id with ret_slots = 4: PadGetUp (0x2200)
|
||||
// ROM: SYSCALL 0x2200; HALT
|
||||
let mut rom = Vec::new();
|
||||
rom.extend_from_slice(&enc_op(OpCode::Syscall));
|
||||
rom.extend_from_slice(&0x2200u32.to_le_bytes());
|
||||
rom.extend_from_slice(&enc_op(OpCode::Halt));
|
||||
|
||||
struct TestNative;
|
||||
impl NativeInterface for TestNative {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
id: u32,
|
||||
_args: &[Value],
|
||||
ret: &mut HostReturn,
|
||||
_ctx: &mut HostContext,
|
||||
) -> Result<(), VmFault> {
|
||||
assert_eq!(id, 0x2200);
|
||||
// Push exactly 4 results in a known order.
|
||||
ret.push_int(11);
|
||||
ret.push_int(22);
|
||||
ret.push_bool(true);
|
||||
ret.push_int(7);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
let mut vm = VirtualMachine::new(rom.clone(), vec![]);
|
||||
|
||||
let mut native = TestNative;
|
||||
let mut ctx = HostContext::new(None);
|
||||
vm.prepare_call("0");
|
||||
// Grant INPUT capability to pass capability gate for PadGetUp
|
||||
vm.set_capabilities(prometeu_hal::syscalls::caps::INPUT);
|
||||
let _ = vm.run_budget(100, &mut native, &mut ctx).expect("VM run failed");
|
||||
|
||||
// Verify top-of-stack order: last pushed is on top
|
||||
let top = vm.operand_stack_top(4);
|
||||
assert_eq!(
|
||||
top,
|
||||
vec![Value::Int64(7), Value::Boolean(true), Value::Int64(22), Value::Int64(11),]
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user