#![allow(dead_code)] use prometeu_bytecode::{ assemble, load_limits::LoadBudget, model::ConstantPoolEntry, registry::*, registry_codec::PbxModule, }; use prometeu_vm::{ HostContext, HostReturn, LogicalFrameEndingReason, NativeInterface, ValidatedProgramImage, VirtualMachine, VmInitError, }; use std::sync::Arc; pub struct Native; impl NativeInterface for Native { fn syscall( &mut self, _: u32, _: &[prometeu_bytecode::Value], _: &mut HostReturn, _: &mut HostContext, ) -> Result<(), prometeu_hal::vm_fault::VmFault> { panic!("identity corpus uses no host syscall") } } pub fn sig(parameters: &[u32], results: &[u32]) -> Signature { Signature { parameters: parameters .iter() .map(|&id| NamedType { type_id: TypeId(id), name: None }) .collect(), results: results.iter().copied().map(TypeId).collect(), } } pub fn types() -> Vec { let field = || NamedType { type_id: TypeId(0), name: None }; vec![ TypeKind::Builtin(BuiltinId::INT64), TypeKind::Builtin(BuiltinId::FLOAT), TypeKind::Builtin(BuiltinId::BOOL), TypeKind::Builtin(BuiltinId::STRING), TypeKind::Builtin(BuiltinId::DYNAMIC), TypeKind::Struct(vec![field()]), TypeKind::Array(TypeId(0)), TypeKind::Trait(vec![]), TypeKind::Trait(vec![]), TypeKind::Fn(sig(&[], &[])), TypeKind::Builtin(BuiltinId::RANDOM), TypeKind::Struct(vec![field()]), TypeKind::Builtin(BuiltinId::COLOR), TypeKind::Builtin(BuiltinId::VEC2), TypeKind::Builtin(BuiltinId::PIXEL), TypeKind::Builtin(BuiltinId::INT32), ] .into_iter() .map(|kind| TypeDecl { name: None, kind }) .collect() } pub fn image( bodies: &[(&str, Signature)], constants: &[ConstantPoolEntry], ) -> Result, VmInitError> { let mut code = vec![]; let mut functions = vec![]; for (source, signature) in bodies { let body = assemble(source).unwrap(); functions.push(FunctionDecl { signature: signature.clone(), local_slots: 8, max_stack_slots: 64, code_offset: code.len() as u32, code_len: body.len() as u32, ..Default::default() }); code.extend(body); } let mut budget = LoadBudget::new(Default::default()); let registry = Registry::resolve( RegistryDeclarations { types: types(), functions, implementations: vec![ ImplementationDecl { owner: TypeId(5), trait_id: TypeId(7), methods: vec![] }, ImplementationDecl { owner: TypeId(5), trait_id: TypeId(8), methods: vec![] }, ], }, code.len(), &mut budget, ) .unwrap(); let bytes = PbxModule { registry: ®istry, code: &code, constants, debug: None, exports: &[], syscalls: &[], } .serialize(&mut budget) .unwrap(); ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), 0) } pub fn vm(bodies: &[(&str, Signature)], constants: &[ConstantPoolEntry]) -> VirtualMachine { let mut vm = VirtualMachine::from_image(image(bodies, constants).unwrap(), Default::default()); vm.prepare_boot_call().unwrap(); vm } pub fn run(vm: &mut VirtualMachine) -> prometeu_vm::BudgetReport { vm.run_budget(1_000_000, &mut Native, &mut HostContext::new(None)).unwrap() } pub fn step(vm: &mut VirtualMachine) -> Result<(), LogicalFrameEndingReason> { vm.step(&mut Native, &mut HostContext::new(None)) } pub fn hex_bytes(value: &str) -> Vec { (0..value.len()).step_by(2).map(|i| u8::from_str_radix(&value[i..i + 2], 16).unwrap()).collect() }