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

smokes: add curated LLVM runner; archive legacy smokes; PHI-off unified across Bridge/Builder; LLVM resolver tracing; minimal Throw lowering; config env getters; dev profile and root cleaner; docs updated; CI workflow runs curated LLVM (PHI-on/off)

Browse Source
This commit is contained in:
Selfhosting Dev
2025-09-16 23:49:36 +09:00
parent 97a76c0571
commit 5c9213cd03
104 changed files with 8094 additions and 2930 deletions
Download Patch File Download Diff File Expand all files Collapse all files

541
plugins/nyash-map-plugin/src/lib.rs
View File

@ -4,9 +4,12 @@
use once_cell::sync::Lazy;
use std::collections::HashMap;
use std::sync::{Mutex, atomic::{AtomicU32, Ordering}};
use std::os::raw::c_char;
use std::ffi::CStr;
use std::os::raw::c_char;
use std::sync::{
atomic::{AtomicU32, Ordering},
Mutex,
};
// Error codes
const NYB_SUCCESS: i32 = 0;
@ -19,37 +22,41 @@ const NYB_E_INVALID_HANDLE: i32 = -8;
// Methods
const METHOD_BIRTH: u32 = 0;
const METHOD_SIZE: u32 = 1;
const METHOD_GET: u32 = 2; // args: i64 key -> TLV i64
const METHOD_HAS: u32 = 3; // args: i64 key -> TLV bool
const METHOD_SET: u32 = 4; // args: key(int|string), value(i64) -> TLV i64 (size)
const METHOD_REMOVE:u32 = 6; // args: key(int|string) -> TLV bool (removed)
const METHOD_SIZE: u32 = 1;
const METHOD_GET: u32 = 2; // args: i64 key -> TLV i64
const METHOD_HAS: u32 = 3; // args: i64 key -> TLV bool
const METHOD_SET: u32 = 4; // args: key(int|string), value(i64) -> TLV i64 (size)
const METHOD_REMOVE: u32 = 6; // args: key(int|string) -> TLV bool (removed)
const METHOD_CLEAR: u32 = 7; // args: () -> TLV i64 (size after clear=0)
const METHOD_KEYS_S:u32 = 8; // args: () -> TLV string (newline-joined keys)
const METHOD_GET_OR:u32 = 9; // args: key(int|string), default(i64) -> TLV i64
const METHOD_FINI: u32 = u32::MAX;
const METHOD_KEYS_S: u32 = 8; // args: () -> TLV string (newline-joined keys)
const METHOD_GET_OR: u32 = 9; // args: key(int|string), default(i64) -> TLV i64
const METHOD_FINI: u32 = u32::MAX;
// Extended string-key methods
const METHOD_SET_STR: u32 = 10; // setS(name: string, val: i64) -> i64(size)
const METHOD_GET_STR: u32 = 11; // getS(name: string) -> i64
const METHOD_HAS_STR: u32 = 12; // hasS(name: string) -> bool
const METHOD_VALUES_S: u32 = 13; // valuesStr() -> string (newline-joined)
const METHOD_TO_JSON: u32 = 14; // toJson() -> string
const METHOD_TO_JSON: u32 = 14; // toJson() -> string
// Type id (nyash.toml に合わせる)
const TYPE_ID_MAP: u32 = 11;
struct MapInstance {
data_i64: HashMap<i64,i64>,
data_str: HashMap<String,i64>,
data_i64: HashMap<i64, i64>,
data_str: HashMap<String, i64>,
}
static INSTANCES: Lazy<Mutex<HashMap<u32, MapInstance>>> = Lazy::new(|| Mutex::new(HashMap::new()));
static INSTANCE_COUNTER: AtomicU32 = AtomicU32::new(1);
#[no_mangle]
pub extern "C" fn nyash_plugin_abi() -> u32 { 1 }
pub extern "C" fn nyash_plugin_abi() -> u32 {
1
}
#[no_mangle]
pub extern "C" fn nyash_plugin_init() -> i32 { NYB_SUCCESS }
pub extern "C" fn nyash_plugin_init() -> i32 {
NYB_SUCCESS
}
#[no_mangle]
pub extern "C" fn nyash_plugin_invoke(
@ -61,44 +68,81 @@ pub extern "C" fn nyash_plugin_invoke(
result: *mut u8,
result_len: *mut usize,
) -> i32 {
if type_id != TYPE_ID_MAP { return NYB_E_INVALID_TYPE; }
if type_id != TYPE_ID_MAP {
return NYB_E_INVALID_TYPE;
}
unsafe {
match method_id {
METHOD_BIRTH => {
if result_len.is_null() { return NYB_E_INVALID_ARGS; }
if preflight(result, result_len, 4) { return NYB_E_SHORT_BUFFER; }
if result_len.is_null() {
return NYB_E_INVALID_ARGS;
}
if preflight(result, result_len, 4) {
return NYB_E_SHORT_BUFFER;
}
let id = INSTANCE_COUNTER.fetch_add(1, Ordering::Relaxed);
if let Ok(mut map) = INSTANCES.lock() {
map.insert(id, MapInstance { data_i64: HashMap::new(), data_str: HashMap::new() });
} else { return NYB_E_PLUGIN_ERROR; }
map.insert(
id,
MapInstance {
data_i64: HashMap::new(),
data_str: HashMap::new(),
},
);
} else {
return NYB_E_PLUGIN_ERROR;
}
std::ptr::copy_nonoverlapping(id.to_le_bytes().as_ptr(), result, 4);
*result_len = 4;
NYB_SUCCESS
}
METHOD_FINI => {
if let Ok(mut map) = INSTANCES.lock() { map.remove(&instance_id); NYB_SUCCESS } else { NYB_E_PLUGIN_ERROR }
if let Ok(mut map) = INSTANCES.lock() {
map.remove(&instance_id);
NYB_SUCCESS
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_SIZE => {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
let sz = inst.data_i64.len() + inst.data_str.len();
write_tlv_i64(sz as i64, result, result_len)
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_GET => {
if let Some(ik) = read_arg_i64(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
match inst.data_i64.get(&ik).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
match inst.data_i64.get(&ik).copied() {
Some(v) => write_tlv_i64(v, result, result_len),
None => NYB_E_INVALID_ARGS,
}
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else if let Some(sk) = read_arg_string(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
match inst.data_str.get(&sk).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
match inst.data_str.get(&sk).copied() {
Some(v) => write_tlv_i64(v, result, result_len),
None => NYB_E_INVALID_ARGS,
}
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else {
NYB_E_INVALID_ARGS
}
@ -106,35 +150,58 @@ pub extern "C" fn nyash_plugin_invoke(
METHOD_HAS => {
if let Some(ik) = read_arg_i64(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data_i64.contains_key(&ik), result, result_len) } else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
if let Some(inst) = map.get(&instance_id) {
write_tlv_bool(inst.data_i64.contains_key(&ik), result, result_len)
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else if let Some(sk) = read_arg_string(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data_str.contains_key(&sk), result, result_len) } else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
if let Some(inst) = map.get(&instance_id) {
write_tlv_bool(inst.data_str.contains_key(&sk), result, result_len)
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else {
NYB_E_INVALID_ARGS
}
}
METHOD_SET => {
// value は i64 限定
let val = match read_arg_i64(args, args_len, 1) { Some(v) => v, None => return NYB_E_INVALID_ARGS };
let val = match read_arg_i64(args, args_len, 1) {
Some(v) => v,
None => return NYB_E_INVALID_ARGS,
};
if let Some(ik) = read_arg_i64(args, args_len, 0) {
if let Ok(mut map) = INSTANCES.lock() {
if let Some(inst) = map.get_mut(&instance_id) {
inst.data_i64.insert(ik, val);
let sz = inst.data_i64.len() + inst.data_str.len();
return write_tlv_i64(sz as i64, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else if let Some(sk) = read_arg_string(args, args_len, 0) {
if let Ok(mut map) = INSTANCES.lock() {
if let Some(inst) = map.get_mut(&instance_id) {
inst.data_str.insert(sk, val);
let sz = inst.data_i64.len() + inst.data_str.len();
return write_tlv_i64(sz as i64, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else {
NYB_E_INVALID_ARGS
}
@ -143,12 +210,28 @@ pub extern "C" fn nyash_plugin_invoke(
if let Ok(mut map) = INSTANCES.lock() {
if let Some(inst) = map.get_mut(&instance_id) {
// try int key
if let Some(ik) = read_arg_i64(args, args_len, 0) { return write_tlv_bool(inst.data_i64.remove(&ik).is_some(), result, result_len); }
if let Some(ik) = read_arg_i64(args, args_len, 0) {
return write_tlv_bool(
inst.data_i64.remove(&ik).is_some(),
result,
result_len,
);
}
// try string key
if let Some(sk) = read_arg_string(args, args_len, 0) { return write_tlv_bool(inst.data_str.remove(&sk).is_some(), result, result_len); }
if let Some(sk) = read_arg_string(args, args_len, 0) {
return write_tlv_bool(
inst.data_str.remove(&sk).is_some(),
result,
result_len,
);
}
NYB_E_INVALID_ARGS
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_CLEAR => {
if let Ok(mut map) = INSTANCES.lock() {
@ -156,23 +239,39 @@ pub extern "C" fn nyash_plugin_invoke(
inst.data_i64.clear();
inst.data_str.clear();
return write_tlv_i64(0, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_KEYS_S => {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
let mut keys: Vec<String> = Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for k in inst.data_i64.keys() { keys.push(k.to_string()); }
for k in inst.data_str.keys() { keys.push(k.clone()); }
let mut keys: Vec<String> =
Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for k in inst.data_i64.keys() {
keys.push(k.to_string());
}
for k in inst.data_str.keys() {
keys.push(k.clone());
}
keys.sort();
let out = keys.join("\n");
return write_tlv_string(&out, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_GET_OR => {
let defv = match read_arg_i64(args, args_len, 1) { Some(v) => v, None => return NYB_E_INVALID_ARGS };
let defv = match read_arg_i64(args, args_len, 1) {
Some(v) => v,
None => return NYB_E_INVALID_ARGS,
};
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
// prefer exact match, else default
@ -185,44 +284,86 @@ pub extern "C" fn nyash_plugin_invoke(
return write_tlv_i64(v, result, result_len);
}
NYB_E_INVALID_ARGS
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_SET_STR => {
let key = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return NYB_E_INVALID_ARGS };
let val = match read_arg_i64(args, args_len, 1) { Some(v) => v, None => return NYB_E_INVALID_ARGS };
let key = match read_arg_string(args, args_len, 0) {
Some(s) => s,
None => return NYB_E_INVALID_ARGS,
};
let val = match read_arg_i64(args, args_len, 1) {
Some(v) => v,
None => return NYB_E_INVALID_ARGS,
};
if let Ok(mut map) = INSTANCES.lock() {
if let Some(inst) = map.get_mut(&instance_id) {
inst.data_str.insert(key, val);
let sz = inst.data_i64.len() + inst.data_str.len();
return write_tlv_i64(sz as i64, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_GET_STR => {
let key = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return NYB_E_INVALID_ARGS };
let key = match read_arg_string(args, args_len, 0) {
Some(s) => s,
None => return NYB_E_INVALID_ARGS,
};
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
match inst.data_str.get(&key).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
match inst.data_str.get(&key).copied() {
Some(v) => write_tlv_i64(v, result, result_len),
None => NYB_E_INVALID_ARGS,
}
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_HAS_STR => {
let key = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return NYB_E_INVALID_ARGS };
let key = match read_arg_string(args, args_len, 0) {
Some(s) => s,
None => return NYB_E_INVALID_ARGS,
};
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data_str.contains_key(&key), result, result_len) } else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
if let Some(inst) = map.get(&instance_id) {
write_tlv_bool(inst.data_str.contains_key(&key), result, result_len)
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_VALUES_S => {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
let mut vals: Vec<String> = Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for v in inst.data_i64.values() { vals.push(v.to_string()); }
for v in inst.data_str.values() { vals.push(v.to_string()); }
let mut vals: Vec<String> =
Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for v in inst.data_i64.values() {
vals.push(v.to_string());
}
for v in inst.data_str.values() {
vals.push(v.to_string());
}
let out = vals.join("\n");
return write_tlv_string(&out, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_TO_JSON => {
if let Ok(map) = INSTANCES.lock() {
@ -230,23 +371,35 @@ pub extern "C" fn nyash_plugin_invoke(
let mut s = String::from("{");
let mut first = true;
for (k, v) in inst.data_str.iter() {
if !first { s.push(','); }
if !first {
s.push(',');
}
first = false;
// JSON string key
s.push('"'); s.push_str(&escape_json(k)); s.push_str("\": ");
s.push('"');
s.push_str(&escape_json(k));
s.push_str("\": ");
s.push_str(&v.to_string());
}
for (k, v) in inst.data_i64.iter() {
if !first { s.push(','); }
if !first {
s.push(',');
}
first = false;
// numeric key as string per JSON
s.push('"'); s.push_str(&k.to_string()); s.push_str("\": ");
s.push('"');
s.push_str(&k.to_string());
s.push_str("\": ");
s.push_str(&v.to_string());
}
s.push('}');
return write_tlv_string(&s, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
_ => NYB_E_INVALID_METHOD,
}
@ -267,7 +420,9 @@ pub struct NyashTypeBoxFfi {
unsafe impl Sync for NyashTypeBoxFfi {}
extern "C" fn mapbox_resolve(name: *const c_char) -> u32 {
if name.is_null() { return 0; }
if name.is_null() {
return 0;
}
let s = unsafe { CStr::from_ptr(name) }.to_string_lossy();
match s.as_ref() {
"size" | "len" => METHOD_SIZE,
@ -280,41 +435,82 @@ extern "C" fn mapbox_resolve(name: *const c_char) -> u32 {
}
}
extern "C" fn mapbox_invoke_id(instance_id: u32, method_id: u32, args: *const u8, args_len: usize, result: *mut u8, result_len: *mut usize) -> i32 {
extern "C" fn mapbox_invoke_id(
instance_id: u32,
method_id: u32,
args: *const u8,
args_len: usize,
result: *mut u8,
result_len: *mut usize,
) -> i32 {
match method_id {
METHOD_SIZE => {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
let sz = inst.data_i64.len() + inst.data_str.len();
return write_tlv_i64(sz as i64, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_GET => {
if let Some(ik) = read_arg_i64(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
match inst.data_i64.get(&ik).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
match inst.data_i64.get(&ik).copied() {
Some(v) => write_tlv_i64(v, result, result_len),
None => NYB_E_INVALID_ARGS,
}
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else if let Some(sk) = read_arg_string(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
match inst.data_str.get(&sk).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else { NYB_E_INVALID_ARGS }
match inst.data_str.get(&sk).copied() {
Some(v) => write_tlv_i64(v, result, result_len),
None => NYB_E_INVALID_ARGS,
}
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else {
NYB_E_INVALID_ARGS
}
}
METHOD_HAS => {
if let Some(ik) = read_arg_i64(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data_i64.contains_key(&ik), result, result_len) } else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
if let Some(inst) = map.get(&instance_id) {
write_tlv_bool(inst.data_i64.contains_key(&ik), result, result_len)
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else if let Some(sk) = read_arg_string(args, args_len, 0) {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data_str.contains_key(&sk), result, result_len) } else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else { NYB_E_INVALID_ARGS }
if let Some(inst) = map.get(&instance_id) {
write_tlv_bool(inst.data_str.contains_key(&sk), result, result_len)
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else {
NYB_E_INVALID_ARGS
}
}
METHOD_SET => {
// key: i64 or string, value: i64
@ -325,55 +521,104 @@ extern "C" fn mapbox_invoke_id(instance_id: u32, method_id: u32, args: *const u8
inst.data_i64.insert(ik, val);
let sz = inst.data_i64.len() + inst.data_str.len();
return write_tlv_i64(sz as i64, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else if let Some(sk) = read_arg_string(args, args_len, 0) {
if let Ok(mut map) = INSTANCES.lock() {
if let Some(inst) = map.get_mut(&instance_id) {
inst.data_str.insert(sk, val);
let sz = inst.data_i64.len() + inst.data_str.len();
return write_tlv_i64(sz as i64, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else { NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_ARGS }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
} else {
NYB_E_INVALID_ARGS
}
} else {
NYB_E_INVALID_ARGS
}
}
METHOD_GET_STR => {
let key = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return NYB_E_INVALID_ARGS };
let key = match read_arg_string(args, args_len, 0) {
Some(s) => s,
None => return NYB_E_INVALID_ARGS,
};
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
match inst.data_str.get(&key).copied() { Some(v) => write_tlv_i64(v, result, result_len), None => NYB_E_INVALID_ARGS }
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
match inst.data_str.get(&key).copied() {
Some(v) => write_tlv_i64(v, result, result_len),
None => NYB_E_INVALID_ARGS,
}
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_HAS_STR => {
let key = match read_arg_string(args, args_len, 0) { Some(s) => s, None => return NYB_E_INVALID_ARGS };
let key = match read_arg_string(args, args_len, 0) {
Some(s) => s,
None => return NYB_E_INVALID_ARGS,
};
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) { write_tlv_bool(inst.data_str.contains_key(&key), result, result_len) } else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
if let Some(inst) = map.get(&instance_id) {
write_tlv_bool(inst.data_str.contains_key(&key), result, result_len)
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_KEYS_S => {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
let mut keys: Vec<String> = Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for k in inst.data_i64.keys() { keys.push(k.to_string()); }
for k in inst.data_str.keys() { keys.push(k.clone()); }
let mut keys: Vec<String> =
Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for k in inst.data_i64.keys() {
keys.push(k.to_string());
}
for k in inst.data_str.keys() {
keys.push(k.clone());
}
keys.sort();
let out = keys.join("\n");
return write_tlv_string(&out, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
METHOD_VALUES_S => {
if let Ok(map) = INSTANCES.lock() {
if let Some(inst) = map.get(&instance_id) {
let mut vals: Vec<String> = Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for v in inst.data_i64.values() { vals.push(v.to_string()); }
for v in inst.data_str.values() { vals.push(v.to_string()); }
let mut vals: Vec<String> =
Vec::with_capacity(inst.data_i64.len() + inst.data_str.len());
for v in inst.data_i64.values() {
vals.push(v.to_string());
}
for v in inst.data_str.values() {
vals.push(v.to_string());
}
let out = vals.join("\n");
return write_tlv_string(&out, result, result_len);
} else { NYB_E_INVALID_HANDLE }
} else { NYB_E_PLUGIN_ERROR }
} else {
NYB_E_INVALID_HANDLE
}
} else {
NYB_E_PLUGIN_ERROR
}
}
_ => NYB_E_INVALID_METHOD,
}
@ -391,7 +636,7 @@ pub static nyash_typebox_MapBox: NyashTypeBoxFfi = NyashTypeBoxFfi {
};
fn escape_json(s: &str) -> String {
let mut out = String::with_capacity(s.len()+8);
let mut out = String::with_capacity(s.len() + 8);
for ch in s.chars() {
match ch {
'"' => out.push_str("\\\""),
@ -409,7 +654,9 @@ fn escape_json(s: &str) -> String {
// TLV helpers
fn preflight(result: *mut u8, result_len: *mut usize, needed: usize) -> bool {
unsafe {
if result_len.is_null() { return false; }
if result_len.is_null() {
return false;
}
if result.is_null() || *result_len < needed {
*result_len = needed;
return true;
@ -419,8 +666,11 @@ fn preflight(result: *mut u8, result_len: *mut usize, needed: usize) -> bool {
}
fn write_tlv_result(payloads: &[(u8, &[u8])], result: *mut u8, result_len: *mut usize) -> i32 {
if result_len.is_null() { return NYB_E_INVALID_ARGS; }
let mut buf: Vec<u8> = Vec::with_capacity(4 + payloads.iter().map(|(_,p)| 4 + p.len()).sum::<usize>());
if result_len.is_null() {
return NYB_E_INVALID_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 {
@ -441,27 +691,44 @@ fn write_tlv_result(payloads: &[(u8, &[u8])], result: *mut u8, result_len: *mut
NYB_SUCCESS
}
fn write_tlv_i64(v: i64, result: *mut u8, result_len: *mut usize) -> i32 { write_tlv_result(&[(3u8, &v.to_le_bytes())], result, result_len) }
fn write_tlv_bool(bv: bool, result: *mut u8, result_len: *mut usize) -> i32 { let b = [if bv {1u8} else {0u8}]; write_tlv_result(&[(1u8, &b)], 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 write_tlv_i64(v: i64, result: *mut u8, result_len: *mut usize) -> i32 {
write_tlv_result(&[(3u8, &v.to_le_bytes())], result, result_len)
}
fn write_tlv_bool(bv: bool, result: *mut u8, result_len: *mut usize) -> i32 {
let b = [if bv { 1u8 } else { 0u8 }];
write_tlv_result(&[(1u8, &b)], 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_i64(args: *const u8, args_len: usize, n: usize) -> Option<i64> {
if args.is_null() || args_len < 4 { return None; }
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; }
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; }
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 == 3 && size == 8 {
let mut b = [0u8;8]; b.copy_from_slice(&buf[off+4..off+12]);
let mut b = [0u8; 8];
b.copy_from_slice(&buf[off + 4..off + 12]);
return Some(i64::from_le_bytes(b));
} else if tag == 2 && size == 4 {
let mut b = [0u8;4]; b.copy_from_slice(&buf[off+4..off+8]);
let mut b = [0u8; 4];
b.copy_from_slice(&buf[off + 4..off + 8]);
return Some(i32::from_le_bytes(b) as i64);
} else { return None; }
} else {
return None;
}
}
off += 4 + size;
}
@ -469,19 +736,27 @@ fn read_arg_i64(args: *const u8, args_len: usize, n: usize) -> Option<i64> {
}
fn read_arg_string(args: *const u8, args_len: usize, n: usize) -> Option<String> {
if args.is_null() || args_len < 4 { return None; }
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; }
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; }
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 {
let s = &buf[off+4..off+4+size];
let s = &buf[off + 4..off + 4 + size];
return Some(String::from_utf8_lossy(s).to_string());
} else { return None; }
} else {
return None;
}
}
off += 4 + size;
}