tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(fmt): add legacy stubs and strip trailing whitespace to unblock cargo fmt

Browse Source
This commit is contained in:
Selfhosting Dev
2025-09-17 07:43:07 +09:00
parent fcf8ce1f3c
commit adbb0201a9
385 changed files with 35622 additions and 15004 deletions
Download Patch File Download Diff File Expand all files Collapse all files

344
src/backend/vm_instructions/extern_call.rs
View File

@ -1,33 +1,60 @@
use crate::backend::vm::ControlFlow;
use crate::backend::{VMError, VMValue, VM};
use crate::box_trait::NyashBox;
use crate::mir::ValueId;
use crate::backend::vm::ControlFlow;
use crate::backend::{VM, VMError, VMValue};
impl VM {
/// Execute ExternCall instruction
pub(crate) fn execute_extern_call(&mut self, dst: Option<ValueId>, iface_name: &str, method_name: &str, args: &[ValueId]) -> Result<ControlFlow, VMError> {
pub(crate) fn execute_extern_call(
&mut self,
dst: Option<ValueId>,
iface_name: &str,
method_name: &str,
args: &[ValueId],
) -> Result<ControlFlow, VMError> {
// Core-13 pure shims: env.local.{get,set}, env.box.new
match (iface_name, method_name) {
("env.local", "get") => {
if args.len() != 1 { return Err(VMError::InvalidInstruction("env.local.get arity".into())); }
if args.len() != 1 {
return Err(VMError::InvalidInstruction("env.local.get arity".into()));
}
let ptr = args[0];
let v = self.get_value(ptr).unwrap_or(crate::backend::vm::VMValue::Void);
if let Some(d) = dst { self.set_value(d, v); }
let v = self
.get_value(ptr)
.unwrap_or(crate::backend::vm::VMValue::Void);
if let Some(d) = dst {
self.set_value(d, v);
}
return Ok(ControlFlow::Continue);
}
("env.local", "set") => {
if args.len() != 2 { return Err(VMError::InvalidInstruction("env.local.set arity".into())); }
if args.len() != 2 {
return Err(VMError::InvalidInstruction("env.local.set arity".into()));
}
let ptr = args[0];
let val = self.get_value(args[1])?;
self.set_value(ptr, val);
if let Some(d) = dst { self.set_value(d, crate::backend::vm::VMValue::Void); }
if let Some(d) = dst {
self.set_value(d, crate::backend::vm::VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.box", "new") => {
if args.is_empty() { return Err(VMError::InvalidInstruction("env.box.new requires type name".into())); }
if args.is_empty() {
return Err(VMError::InvalidInstruction(
"env.box.new requires type name".into(),
));
}
// first arg must be Const String type name
let ty = self.get_value(args[0])?;
let ty_name = match ty { crate::backend::vm::VMValue::String(s) => s, _ => return Err(VMError::InvalidInstruction("env.box.new first arg must be string".into())) };
let ty_name = match ty {
crate::backend::vm::VMValue::String(s) => s,
_ => {
return Err(VMError::InvalidInstruction(
"env.box.new first arg must be string".into(),
))
}
};
// remaining args as NyashBox
let mut ny_args: Vec<Box<dyn NyashBox>> = Vec::new();
for id in args.iter().skip(1) {
@ -36,8 +63,17 @@ impl VM {
}
let reg = crate::runtime::box_registry::get_global_registry();
match reg.create_box(&ty_name, &ny_args) {
Ok(b) => { if let Some(d) = dst { self.set_value(d, crate::backend::vm::VMValue::from_nyash_box(b)); } }
Err(e) => { return Err(VMError::InvalidInstruction(format!("env.box.new failed for {}: {}", ty_name, e))); }
Ok(b) => {
if let Some(d) = dst {
self.set_value(d, crate::backend::vm::VMValue::from_nyash_box(b));
}
}
Err(e) => {
return Err(VMError::InvalidInstruction(format!(
"env.box.new failed for {}: {}",
ty_name, e
)));
}
}
return Ok(ControlFlow::Continue);
}
@ -45,41 +81,90 @@ impl VM {
}
// Optional routing to name→slot handlers for stability and diagnostics
if crate::config::env::extern_route_slots() {
if let Some(slot) = crate::runtime::extern_registry::resolve_slot(iface_name, method_name) {
if let Some(slot) =
crate::runtime::extern_registry::resolve_slot(iface_name, method_name)
{
// Decode args to VMValue as needed by handlers below
let vm_args: Vec<VMValue> = args.iter().filter_map(|a| self.get_value(*a).ok()).collect();
let vm_args: Vec<VMValue> = args
.iter()
.filter_map(|a| self.get_value(*a).ok())
.collect();
match (iface_name, method_name, slot) {
("env.local", "get", 40) => {
if let Some(d) = dst { if let Some(a0) = args.get(0) { let v = self.get_value(*a0).unwrap_or(VMValue::Void); self.set_value(d, v); } }
if let Some(d) = dst {
if let Some(a0) = args.get(0) {
let v = self.get_value(*a0).unwrap_or(VMValue::Void);
self.set_value(d, v);
}
}
return Ok(ControlFlow::Continue);
}
("env.local", "set", 41) => {
if args.len() >= 2 { let ptr = args[0]; let val = vm_args.get(1).cloned().unwrap_or(VMValue::Void); self.set_value(ptr, val); }
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if args.len() >= 2 {
let ptr = args[0];
let val = vm_args.get(1).cloned().unwrap_or(VMValue::Void);
self.set_value(ptr, val);
}
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.box", "new", 50) => {
if vm_args.is_empty() { return Err(VMError::InvalidInstruction("env.box.new requires type".into())); }
let ty = &vm_args[0]; let ty_name = match ty { VMValue::String(s) => s.clone(), _ => return Err(VMError::InvalidInstruction("env.box.new first arg must be string".into())) };
if vm_args.is_empty() {
return Err(VMError::InvalidInstruction(
"env.box.new requires type".into(),
));
}
let ty = &vm_args[0];
let ty_name = match ty {
VMValue::String(s) => s.clone(),
_ => {
return Err(VMError::InvalidInstruction(
"env.box.new first arg must be string".into(),
))
}
};
let mut ny_args: Vec<Box<dyn NyashBox>> = Vec::new();
for v in vm_args.iter().skip(1) { ny_args.push(v.to_nyash_box()); }
for v in vm_args.iter().skip(1) {
ny_args.push(v.to_nyash_box());
}
let reg = crate::runtime::box_registry::get_global_registry();
match reg.create_box(&ty_name, &ny_args) {
Ok(b) => { if let Some(d) = dst { self.set_value(d, VMValue::from_nyash_box(b)); } }
Err(e) => { return Err(VMError::InvalidInstruction(format!("env.box.new failed for {}: {}", ty_name, e))); }
Ok(b) => {
if let Some(d) = dst {
self.set_value(d, VMValue::from_nyash_box(b));
}
}
Err(e) => {
return Err(VMError::InvalidInstruction(format!(
"env.box.new failed for {}: {}",
ty_name, e
)));
}
}
return Ok(ControlFlow::Continue);
}
("env.console", m @ ("log" | "warn" | "error" | "println"), 10) => {
if let Some(a0) = vm_args.get(0) {
match m { "warn" => eprintln!("[warn] {}", a0.to_string()), "error" => eprintln!("[error] {}", a0.to_string()), _ => println!("{}", a0.to_string()), }
match m {
"warn" => eprintln!("[warn] {}", a0.to_string()),
"error" => eprintln!("[error] {}", a0.to_string()),
_ => println!("{}", a0.to_string()),
}
}
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
return Ok(ControlFlow::Continue);
}
("env.debug", "trace", 11) => {
if let Some(a0) = vm_args.get(0) { eprintln!("[trace] {}", a0.to_string()); }
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(a0) = vm_args.get(0) {
eprintln!("[trace] {}", a0.to_string());
}
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.runtime", "checkpoint", 12) => {
@ -88,21 +173,35 @@ impl VM {
eprintln!("[rt] checkpoint @{} bb={} pc={}", func, bb, pc);
}
self.runtime.gc.safepoint();
if let Some(s) = &self.runtime.scheduler { s.poll(); }
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(s) = &self.runtime.scheduler {
s.poll();
}
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.future", "new", 20) | ("env.future", "birth", 20) => {
// Create a new Future and optionally set initial value from arg0
let fut = crate::boxes::future::FutureBox::new();
if let Some(a0) = vm_args.get(0) { fut.set_result(a0.to_nyash_box()); }
if let Some(d) = dst { self.set_value(d, VMValue::Future(fut)); }
if let Some(a0) = vm_args.get(0) {
fut.set_result(a0.to_nyash_box());
}
if let Some(d) = dst {
self.set_value(d, VMValue::Future(fut));
}
return Ok(ControlFlow::Continue);
}
("env.future", "set", 21) => {
// set(future, value)
if vm_args.len() >= 2 { if let VMValue::Future(f) = &vm_args[0] { f.set_result(vm_args[1].to_nyash_box()); } }
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if vm_args.len() >= 2 {
if let VMValue::Future(f) = &vm_args[0] {
f.set_result(vm_args[1].to_nyash_box());
}
}
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.future", "await", 22) => {
@ -112,21 +211,57 @@ impl VM {
let max_ms = crate::config::env::await_max_ms();
while !fb.ready() {
std::thread::yield_now();
if start.elapsed() >= std::time::Duration::from_millis(max_ms) { break; }
if start.elapsed() >= std::time::Duration::from_millis(max_ms) {
break;
}
}
let result = if fb.ready() { fb.get() } else { Box::new(crate::box_trait::StringBox::new("Timeout")) };
let result = if fb.ready() {
fb.get()
} else {
Box::new(crate::box_trait::StringBox::new("Timeout"))
};
let ok = crate::boxes::result::NyashResultBox::new_ok(result);
if let Some(d) = dst { self.set_value(d, VMValue::from_nyash_box(Box::new(ok))); }
} else if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(d) = dst {
self.set_value(d, VMValue::from_nyash_box(Box::new(ok)));
}
} else if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.task", "cancelCurrent", 30) => {
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.task", "currentToken", 31) => {
if let Some(d) = dst {
self.set_value(d, VMValue::Integer(0));
}
return Ok(ControlFlow::Continue);
}
("env.task", "yieldNow", 32) => {
std::thread::yield_now();
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.task", "cancelCurrent", 30) => { if let Some(d) = dst { self.set_value(d, VMValue::Void); } return Ok(ControlFlow::Continue); }
("env.task", "currentToken", 31) => { if let Some(d) = dst { self.set_value(d, VMValue::Integer(0)); } return Ok(ControlFlow::Continue); }
("env.task", "yieldNow", 32) => { std::thread::yield_now(); if let Some(d) = dst { self.set_value(d, VMValue::Void); } return Ok(ControlFlow::Continue); }
("env.task", "sleepMs", 33) => {
let ms = vm_args.get(0).map(|v| match v { VMValue::Integer(i) => *i, _ => 0 }).unwrap_or(0);
if ms > 0 { std::thread::sleep(std::time::Duration::from_millis(ms as u64)); }
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
let ms = vm_args
.get(0)
.map(|v| match v {
VMValue::Integer(i) => *i,
_ => 0,
})
.unwrap_or(0);
if ms > 0 {
std::thread::sleep(std::time::Duration::from_millis(ms as u64));
}
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
_ => { /* fallthrough to host */ }
@ -137,24 +272,38 @@ impl VM {
match (iface_name, method_name) {
("env.modules", "set") => {
// Expect two args
let vm_args: Vec<VMValue> = args.iter().filter_map(|a| self.get_value(*a).ok()).collect();
let vm_args: Vec<VMValue> = args
.iter()
.filter_map(|a| self.get_value(*a).ok())
.collect();
if vm_args.len() >= 2 {
let key = vm_args[0].to_string();
let val_box = vm_args[1].to_nyash_box();
crate::runtime::modules_registry::set(key, val_box);
}
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
("env.modules", "get") => {
let vm_args: Vec<VMValue> = args.iter().filter_map(|a| self.get_value(*a).ok()).collect();
let vm_args: Vec<VMValue> = args
.iter()
.filter_map(|a| self.get_value(*a).ok())
.collect();
if let Some(k) = vm_args.get(0) {
let key = k.to_string();
if let Some(v) = crate::runtime::modules_registry::get(&key) {
if let Some(d) = dst { self.set_value(d, VMValue::from_nyash_box(v)); }
else { /* no dst */ }
} else if let Some(d) = dst { self.set_value(d, VMValue::Void); }
} else if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(d) = dst {
self.set_value(d, VMValue::from_nyash_box(v));
} else { /* no dst */
}
} else if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
} else if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
_ => {}
@ -164,7 +313,10 @@ impl VM {
// Name-route minimal registry even when slot routing is disabled
if iface_name == "env.modules" {
// Decode args as VMValue for convenience
let vm_args: Vec<VMValue> = args.iter().filter_map(|a| self.get_value(*a).ok()).collect();
let vm_args: Vec<VMValue> = args
.iter()
.filter_map(|a| self.get_value(*a).ok())
.collect();
match method_name {
"set" => {
if vm_args.len() >= 2 {
@ -172,16 +324,24 @@ impl VM {
let val_box = vm_args[1].to_nyash_box();
crate::runtime::modules_registry::set(key, val_box);
}
if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
"get" => {
if let Some(k) = vm_args.get(0) {
let key = k.to_string();
if let Some(v) = crate::runtime::modules_registry::get(&key) {
if let Some(d) = dst { self.set_value(d, VMValue::from_nyash_box(v)); }
} else if let Some(d) = dst { self.set_value(d, VMValue::Void); }
} else if let Some(d) = dst { self.set_value(d, VMValue::Void); }
if let Some(d) = dst {
self.set_value(d, VMValue::from_nyash_box(v));
}
} else if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
} else if let Some(d) = dst {
self.set_value(d, VMValue::Void);
}
return Ok(ControlFlow::Continue);
}
_ => {}
@ -190,30 +350,78 @@ impl VM {
// Evaluate arguments as NyashBox for loader
let mut nyash_args: Vec<Box<dyn NyashBox>> = Vec::new();
for arg_id in args { let arg_value = self.get_value(*arg_id)?; nyash_args.push(arg_value.to_nyash_box()); }
for arg_id in args {
let arg_value = self.get_value(*arg_id)?;
nyash_args.push(arg_value.to_nyash_box());
}
if crate::config::env::extern_trace() {
if let Some(slot) = crate::runtime::extern_registry::resolve_slot(iface_name, method_name) {
eprintln!("[EXT] call {}.{} slot={} argc={}", iface_name, method_name, slot, nyash_args.len());
} else { eprintln!("[EXT] call {}.{} argc={}", iface_name, method_name, nyash_args.len()); }
if let Some(slot) =
crate::runtime::extern_registry::resolve_slot(iface_name, method_name)
{
eprintln!(
"[EXT] call {}.{} slot={} argc={}",
iface_name,
method_name,
slot,
nyash_args.len()
);
} else {
eprintln!(
"[EXT] call {}.{} argc={}",
iface_name,
method_name,
nyash_args.len()
);
}
}
let host = crate::runtime::get_global_plugin_host();
let host = host.read().map_err(|_| VMError::InvalidInstruction("Plugin host lock poisoned".into()))?;
let host = host
.read()
.map_err(|_| VMError::InvalidInstruction("Plugin host lock poisoned".into()))?;
match host.extern_call(iface_name, method_name, &nyash_args) {
Ok(Some(result_box)) => { if let Some(dst_id) = dst { self.set_value(dst_id, VMValue::from_nyash_box(result_box)); } }
Ok(None) => { if let Some(dst_id) = dst { self.set_value(dst_id, VMValue::Void); } }
Ok(Some(result_box)) => {
if let Some(dst_id) = dst {
self.set_value(dst_id, VMValue::from_nyash_box(result_box));
}
}
Ok(None) => {
if let Some(dst_id) = dst {
self.set_value(dst_id, VMValue::Void);
}
}
Err(_) => {
let strict = crate::config::env::extern_strict() || crate::config::env::abi_strict();
let strict =
crate::config::env::extern_strict() || crate::config::env::abi_strict();
let mut msg = String::new();
if strict { msg.push_str("ExternCall STRICT: unregistered or unsupported call "); } else { msg.push_str("ExternCall failed: "); }
if strict {
msg.push_str("ExternCall STRICT: unregistered or unsupported call ");
} else {
msg.push_str("ExternCall failed: ");
}
msg.push_str(&format!("{}.{}", iface_name, method_name));
if let Err(detail) = crate::runtime::extern_registry::check_arity(iface_name, method_name, nyash_args.len()) { msg.push_str(&format!(" ({})", detail)); }
if let Some(spec) = crate::runtime::extern_registry::resolve(iface_name, method_name) {
msg.push_str(&format!(" (expected arity {}..{})", spec.min_arity, spec.max_arity));
if let Err(detail) = crate::runtime::extern_registry::check_arity(
iface_name,
method_name,
nyash_args.len(),
) {
msg.push_str(&format!(" ({})", detail));
}
if let Some(spec) =
crate::runtime::extern_registry::resolve(iface_name, method_name)
{
msg.push_str(&format!(
" (expected arity {}..{})",
spec.min_arity, spec.max_arity
));
} else {
let known = crate::runtime::extern_registry::known_for_iface(iface_name);
if !known.is_empty() { msg.push_str(&format!("; known methods: {}", known.join(", "))); }
else { let ifaces = crate::runtime::extern_registry::all_ifaces(); msg.push_str(&format!("; known interfaces: {}", ifaces.join(", "))); }
if !known.is_empty() {
msg.push_str(&format!("; known methods: {}", known.join(", ")));
} else {
let ifaces = crate::runtime::extern_registry::all_ifaces();
msg.push_str(&format!("; known interfaces: {}", ifaces.join(", ")));
}
}
return Err(VMError::InvalidInstruction(msg));
}