use crate::compiler::Program;
use crate::host::{BeginDef, ClassDef, MethodDef, ProcDef, RescueDef, Visibility};
use fusevm::Chunk;
use rkyv::{Archive, Deserialize as RkyvDe, Serialize as RkyvSer};
use serde::{Deserialize, Serialize};
use std::hash::{Hash, Hasher};
use std::path::PathBuf;
const SCHEMA: u64 = 15;
#[derive(Archive, RkyvSer, RkyvDe, Default)]
#[archive(check_bytes)]
struct Shard {
stamp: u64,
entries: Vec<Entry>,
}
#[derive(Archive, RkyvSer, RkyvDe)]
#[archive(check_bytes)]
struct Entry {
key: u64,
blob: Vec<u8>,
}
type CMethod = (
String,
Vec<String>,
Option<usize>,
Vec<String>,
Option<String>,
Option<String>,
u16,
u16,
u16,
Vec<String>,
Chunk,
u16,
u32,
);
type CClass = (
String,
Option<String>,
Vec<CMethod>,
Vec<String>,
Vec<String>,
Vec<String>,
Vec<CMethod>,
bool,
Vec<(String, u8)>,
);
type CRescue = (Vec<String>, Option<usize>, usize);
type CBegin = (usize, Vec<CRescue>, Option<usize>);
type CProc = (
Vec<String>,
Option<usize>,
Chunk,
u16,
u16,
Vec<String>,
Vec<String>,
Option<String>,
Option<String>,
u32,
Vec<String>,
u32,
);
#[derive(Serialize, Deserialize)]
struct CProg {
main: Chunk,
methods: Vec<CMethod>,
classes: Vec<CClass>,
begins: Vec<CBegin>,
procs: Vec<CProc>,
#[serde(default)]
deps: Vec<(String, u64)>,
}
pub fn program_to_blob(prog: &Program) -> Result<Vec<u8>, String> {
let cp = to_cprog(prog);
bincode::serialize(&cp).map_err(|e| format!("aot program encode: {e}"))
}
pub fn program_from_blob(bytes: &[u8]) -> Result<Program, String> {
let cp: CProg = bincode::deserialize(bytes).map_err(|e| format!("aot program decode: {e}"))?;
Ok(from_cprog(cp))
}
pub fn key_for(src: &str) -> u64 {
let mut h = rustc_hash::FxHasher::default();
SCHEMA.hash(&mut h);
src.hash(&mut h);
h.finish()
}
pub fn key_for_file(abs_path: &str, src: &str) -> u64 {
let mut h = rustc_hash::FxHasher::default();
SCHEMA.hash(&mut h);
abs_path.hash(&mut h);
src.hash(&mut h);
h.finish()
}
fn shard_dir() -> Option<PathBuf> {
let dir = dirs::home_dir()?.join(".rubylang");
let _ = std::fs::create_dir_all(&dir);
Some(dir)
}
fn shard_path() -> Option<PathBuf> {
Some(shard_dir()?.join("scripts.rkyv"))
}
fn build_stamp() -> u64 {
match std::env::current_exe() {
Ok(p) => exe_stamp(&p),
Err(_) => exe_stamp(std::path::Path::new("")),
}
}
pub fn exe_stamp(path: &std::path::Path) -> u64 {
let mut h = rustc_hash::FxHasher::default();
SCHEMA.hash(&mut h);
env!("CARGO_PKG_VERSION").hash(&mut h);
if let Ok(md) = std::fs::metadata(path) {
md.len().hash(&mut h);
if let Ok(t) = md.modified() {
if let Ok(d) = t.duration_since(std::time::UNIX_EPOCH) {
d.as_nanos().hash(&mut h);
}
}
}
h.finish()
}
struct ShardLock(Option<std::fs::File>);
impl ShardLock {
fn acquire() -> ShardLock {
let Some(dir) = shard_dir() else {
return ShardLock(None);
};
let Ok(f) = std::fs::OpenOptions::new()
.create(true)
.truncate(false)
.write(true)
.open(dir.join("scripts.lock"))
else {
return ShardLock(None);
};
use std::os::unix::io::AsRawFd;
if unsafe { libc::flock(f.as_raw_fd(), libc::LOCK_EX) } != 0 {
return ShardLock(None);
}
ShardLock(Some(f))
}
}
impl Drop for ShardLock {
fn drop(&mut self) {
if let Some(f) = &self.0 {
use std::os::unix::io::AsRawFd;
unsafe { libc::flock(f.as_raw_fd(), libc::LOCK_UN) };
}
}
}
fn load_shard() -> Shard {
let Some(path) = shard_path() else {
return Shard::default();
};
let Ok(bytes) = std::fs::read(&path) else {
return Shard::default();
};
let shard = rkyv::from_bytes::<Shard>(&bytes).unwrap_or_default();
if shard.stamp != build_stamp() {
return Shard::default();
}
shard
}
fn write_shard(shard: &mut Shard) -> Result<(), String> {
let path = shard_path().ok_or("no home dir for cache")?;
shard.stamp = build_stamp();
let bytes = rkyv::to_bytes::<_, 4096>(shard).map_err(|e| format!("cache serialize: {e}"))?;
let tmp = path.with_extension(format!("rkyv.tmp.{}", std::process::id()));
std::fs::write(&tmp, &bytes).map_err(|e| format!("cache write: {e}"))?;
std::fs::rename(&tmp, &path).map_err(|e| {
let _ = std::fs::remove_file(&tmp);
format!("cache write: {e}")
})
}
pub fn load(src: &str) -> Option<Program> {
load_keyed(key_for(src))
}
pub fn load_file(abs_path: &str, src: &str) -> Option<Program> {
load_keyed(key_for_file(abs_path, src))
}
fn load_keyed(key: u64) -> Option<Program> {
let shard = load_shard();
let entry = shard.entries.iter().find(|e| e.key == key)?;
let cp: CProg = bincode::deserialize(&entry.blob).ok()?;
for (path, hash) in &cp.deps {
if let Ok(cur) = std::fs::read_to_string(path) {
if key_for(&cur) != *hash {
return None; }
}
}
Some(from_cprog(cp))
}
pub fn store(src: &str, prog: &Program) -> Result<(), String> {
store_keyed(key_for(src), prog, Vec::new())
}
pub fn store_bundle(
abs_path: &str,
src: &str,
prog: &Program,
deps: Vec<(String, u64)>,
) -> Result<(), String> {
store_keyed(key_for_file(abs_path, src), prog, deps)
}
fn store_keyed(key: u64, prog: &Program, deps: Vec<(String, u64)>) -> Result<(), String> {
let mut cp = to_cprog(prog);
cp.deps = deps;
let blob = bincode::serialize(&cp).map_err(|e| format!("cache encode: {e}"))?;
let _lock = ShardLock::acquire();
let mut shard = load_shard();
shard.entries.retain(|e| e.key != key);
shard.entries.push(Entry { key, blob });
write_shard(&mut shard)
}
fn m_to(name: &str, m: &MethodDef) -> CMethod {
(
name.to_string(),
m.params.clone(),
m.splat,
m.kwparams.clone(),
m.kwsplat.clone(),
m.blockparam.clone(),
m.req,
m.opt,
m.post,
m.kwreq.clone(),
(*m.chunk).clone(),
m.slot_params,
m.line,
)
}
fn m_from(
(
name,
params,
splat,
kwparams,
kwsplat,
blockparam,
req,
opt,
post,
kwreq,
chunk,
slot_params,
line,
): CMethod,
) -> (String, MethodDef) {
(
name,
MethodDef {
chunk_id: crate::host::next_method_chunk_id(),
params,
splat,
kwparams,
kwsplat,
blockparam,
req,
opt,
post,
kwreq,
chunk: std::sync::Arc::new(chunk),
slot_params,
line,
file: None,
},
)
}
fn to_cprog(prog: &Program) -> CProg {
CProg {
deps: Vec::new(),
main: prog.main.clone(),
methods: prog.methods.iter().map(|(n, m)| m_to(n, m)).collect(),
classes: prog
.classes
.iter()
.map(|(n, c)| {
let methods = c.methods.iter().map(|(mn, m)| m_to(mn, m)).collect();
let class_methods = c.class_methods.iter().map(|(mn, m)| m_to(mn, m)).collect();
(
n.clone(),
c.superclass.clone(),
methods,
c.includes.clone(),
c.prepends.clone(),
c.extends.clone(),
class_methods,
c.is_module,
c.visibility
.iter()
.map(|(n, v)| (n.clone(), v.as_u8()))
.collect(),
)
})
.collect(),
begins: prog
.begins
.iter()
.map(|bd| {
let rescues = bd
.rescues
.iter()
.map(|r| (r.classes.clone(), r.splat, r.body))
.collect();
(bd.body, rescues, bd.ensure)
})
.collect(),
procs: prog
.procs
.iter()
.map(|p| {
(
p.params.clone(),
p.splat,
p.chunk.clone(),
p.arity.req,
p.arity.opt,
p.arity.kwnames.clone(),
p.arity.kwreq.clone(),
p.arity.kwsplat.clone(),
p.arity.blockparam.clone(),
p.block_depth,
p.arity.locals.clone(),
p.line,
)
})
.collect(),
}
}
fn from_cprog(cp: CProg) -> Program {
Program {
main: cp.main,
methods: cp.methods.into_iter().map(m_from).collect(),
classes: cp
.classes
.into_iter()
.map(
|(
n,
superclass,
methods,
includes,
prepends,
extends,
class_methods,
is_module,
visibility,
)| {
let methods = methods.into_iter().map(m_from).collect();
let class_methods = class_methods.into_iter().map(m_from).collect();
let visibility = visibility
.into_iter()
.map(|(name, v)| (name, Visibility::from_u8(v)))
.collect();
(
n,
ClassDef {
superclass,
methods,
includes,
prepends,
extends,
class_methods,
visibility,
class_visibility: Default::default(),
is_module,
},
)
},
)
.collect(),
begins: cp
.begins
.into_iter()
.map(|(body, rescues, ensure)| {
let rescues = rescues
.into_iter()
.map(|(classes, splat, body)| RescueDef {
classes,
splat,
body,
})
.collect();
BeginDef {
body,
rescues,
ensure,
}
})
.collect(),
procs: cp
.procs
.into_iter()
.map(
|(
params,
splat,
chunk,
req,
opt,
kwnames,
kwreq,
kwsplat,
blockparam,
block_depth,
locals,
line,
)| ProcDef {
params,
splat,
chunk,
arity: crate::ast::BlockArity {
req,
opt,
kwnames,
kwreq,
kwsplat,
blockparam,
locals,
},
block_depth,
line,
file: None,
},
)
.collect(),
}
}