Phase 10.7/10.5c: include cycle detection (VM/Interpreter), minimal pyc IR→Nyash, String unification bridge (VM partial), add core plugins: RegexBox/EncodingBox/TOMLBox/PathBox + examples; wire nyash.toml; begin String interop for internal vs plugin boxes; update CURRENT_TASK.md

plugins/nyash-path-plugin/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "nyash-path-plugin"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "staticlib"]
+
+[dependencies]
+once_cell = "1.20"
+path-clean = "1.0"
+

plugins/nyash-path-plugin/src/lib.rs

@@ -0,0 +1,114 @@
+//! Nyash PathBox Plugin - minimal path ops (join, dirname, basename, extname, isAbs, normalize)
+
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::path::{Path, Component};
+use std::sync::{Mutex, atomic::{AtomicU32, Ordering}};
+
+const OK: i32 = 0;
+const E_SHORT: i32 = -1;
+const E_TYPE: i32 = -2;
+const E_METHOD: i32 = -3;
+const E_ARGS: i32 = -4;
+const E_PLUGIN: i32 = -5;
+
+const M_BIRTH: u32 = 0;        // constructor -> instance
+const M_JOIN: u32 = 1;         // join(base, rest) -> string
+const M_DIRNAME: u32 = 2;      // dirname(path) -> string
+const M_BASENAME: u32 = 3;     // basename(path) -> string
+const M_EXTNAME: u32 = 4;      // extname(path) -> string
+const M_IS_ABS: u32 = 5;       // isAbs(path) -> bool
+const M_NORMALIZE: u32 = 6;    // normalize(path) -> string
+const M_FINI: u32 = u32::MAX;  // fini
+
+const TYPE_ID_PATH: u32 = 55;
+
+struct PathInstance; // stateless
+
+static INST: Lazy<Mutex<HashMap<u32, PathInstance>>> = Lazy::new(|| Mutex::new(HashMap::new()));
+static NEXT_ID: AtomicU32 = AtomicU32::new(1);
+
+#[no_mangle]
+pub extern "C" fn nyash_plugin_abi() -> u32 { 1 }
+
+#[no_mangle]
+pub extern "C" fn nyash_plugin_init() -> i32 { OK }
+
+#[no_mangle]
+pub extern "C" fn nyash_plugin_invoke(
+    type_id: u32,
+    method_id: u32,
+    instance_id: u32,
+    args: *const u8,
+    args_len: usize,
+    result: *mut u8,
+    result_len: *mut usize,
+) -> i32 {
+    if type_id != TYPE_ID_PATH { return E_TYPE; }
+    unsafe {
+        match method_id {
+            M_BIRTH => {
+                if result_len.is_null() { return E_ARGS; }
+                if preflight(result, result_len, 4) { return E_SHORT; }
+                let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
+                if let Ok(mut m) = INST.lock() { m.insert(id, PathInstance); } else { return E_PLUGIN; }
+                let b = id.to_le_bytes(); std::ptr::copy_nonoverlapping(b.as_ptr(), result, 4); *result_len = 4; OK
+            }
+            M_FINI => { if let Ok(mut m) = INST.lock() { m.remove(&instance_id); OK } else { E_PLUGIN } }
+            M_JOIN => {
+                let base = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
+                let rest = match read_arg_string(args, args_len, 1) { Some(s) => s, None => return E_ARGS };
+                let joined = if base.ends_with('/') || base.ends_with('\\') { format!("{}{}", base, rest) } else { format!("{}/{}", base, rest) };
+                write_tlv_string(&joined, result, result_len)
+            }
+            M_DIRNAME => {
+                let p = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
+                let d = Path::new(&p).parent().map(|x| x.to_string_lossy().to_string()).unwrap_or_else(|| "".to_string());
+                write_tlv_string(&d, result, result_len)
+            }
+            M_BASENAME => {
+                let p = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
+                let b = Path::new(&p).file_name().map(|x| x.to_string_lossy().to_string()).unwrap_or_else(|| "".to_string());
+                write_tlv_string(&b, result, result_len)
+            }
+            M_EXTNAME => {
+                let p = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
+                let ext = Path::new(&p).extension().map(|x| format!(".{}", x.to_string_lossy())).unwrap_or_else(|| "".to_string());
+                write_tlv_string(&ext, result, result_len)
+            }
+            M_IS_ABS => {
+                let p = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
+                let abs = Path::new(&p).is_absolute() || p.contains(":\\");
+                write_tlv_bool(abs, result, result_len)
+            }
+            M_NORMALIZE => {
+                let p = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return E_ARGS };
+                let norm = path_clean::PathClean::clean(Path::new(&p));
+                write_tlv_string(norm.to_string_lossy().as_ref(), result, result_len)
+            }
+            _ => E_METHOD,
+        }
+    }
+}
+
+fn preflight(result: *mut u8, result_len: *mut usize, needed: usize) -> bool {
+    unsafe { if result_len.is_null() { return false; } if result.is_null() || *result_len < needed { *result_len = needed; return true; } }
+    false
+}
+fn write_tlv_result(payloads: &[(u8, &[u8])], result: *mut u8, result_len: *mut usize) -> i32 {
+    if result_len.is_null() { return E_ARGS; }
+    let mut buf: Vec<u8> = Vec::with_capacity(4 + payloads.iter().map(|(_,p)| 4 + p.len()).sum::<usize>());
+    buf.extend_from_slice(&1u16.to_le_bytes()); buf.extend_from_slice(&(payloads.len() as u16).to_le_bytes());
+    for (tag, payload) in payloads { buf.push(*tag); buf.push(0); buf.extend_from_slice(&(payload.len() as u16).to_le_bytes()); buf.extend_from_slice(payload); }
+    unsafe { let needed = buf.len(); if result.is_null() || *result_len < needed { *result_len = needed; return E_SHORT; } std::ptr::copy_nonoverlapping(buf.as_ptr(), result, needed); *result_len = needed; }
+    OK
+}
+fn write_tlv_bool(v: bool, result: *mut u8, result_len: *mut usize) -> i32 { write_tlv_result(&[(1u8, &[if v {1u8} else {0u8}])], result, result_len) }
+fn write_tlv_string(s: &str, result: *mut u8, result_len: *mut usize) -> i32 { write_tlv_result(&[(6u8, s.as_bytes())], result, result_len) }
+
+fn read_arg_string(args: *const u8, args_len: usize, n: usize) -> Option<String> {
+    if args.is_null() || args_len < 4 { return None; }
+    let buf = unsafe { std::slice::from_raw_parts(args, args_len) };
+    let mut off = 4usize; for i in 0..=n { if buf.len() < off + 4 { return None; } let tag = buf[off]; let size = u16::from_le_bytes([buf[off+2], buf[off+3]]) as usize; if buf.len() < off + 4 + size { return None; } if i == n { if tag == 6 || tag == 7 { return Some(String::from_utf8_lossy(&buf[off+4..off+4+size]).to_string()); } else { return None; } } off += 4 + size; }
+    None
+}