#![doc = include_str!("../README.md")]
#![warn(missing_docs)]
extern crate self as mirascript_vm;
mod bytecode;
mod error;
mod interpreter;
mod operations;
mod standard_library;
mod value;
use std::{
num::NonZeroU64,
rc::Rc,
sync::atomic::{AtomicU64, Ordering},
time::{Duration, SystemTime, UNIX_EPOCH},
};
pub use core::{CompileConfig, DiagnosticPositionEncoding, InputMode};
pub use mirascript_core as core;
pub use mirascript_vm_derive::{MiraArray, MiraRecord};
pub use error::*;
pub use interpreter::Runtime;
pub(crate) use value::MiraValueKind;
pub use value::{
MiraArray, MiraExtern, MiraFunction, MiraHandle, MiraManageable, MiraModule, MiraNativeFn,
MiraRecord, MiraShapedArray, MiraShapedRecord, MiraType, MiraValue,
};
use bytecode::Program;
static NEXT_SCRIPT_ID: AtomicU64 = AtomicU64::new(1);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ScriptId(NonZeroU64);
impl ScriptId {
fn new() -> Self {
let id = NEXT_SCRIPT_ID.fetch_add(1, Ordering::Relaxed);
Self(NonZeroU64::new(id).expect("MiraScript identifier space exhausted"))
}
}
#[derive(Clone, Debug)]
pub struct MiraScript {
id: ScriptId,
program: Rc<Program>,
}
impl MiraScript {
pub fn id(&self) -> ScriptId {
self.id
}
}
#[derive(Clone)]
pub struct RunOptions {
pub timeout: Duration,
pub checkpoint_interval: u32,
pub max_call_depth: u32,
pub max_array_len: usize,
pub providers: Rc<dyn RuntimeProviders>,
}
pub trait RuntimeProviders {
fn random(&self) -> f64 {
rand::random()
}
fn now_millis(&self) -> i64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as i64
}
fn debug(&self, message: &str) {
eprintln!("{message}");
}
}
struct SystemRuntimeProviders;
impl RuntimeProviders for SystemRuntimeProviders {}
std::thread_local! {
static DEFAULT_RUNTIME_PROVIDERS: Rc<dyn RuntimeProviders> = Rc::new(SystemRuntimeProviders);
}
impl Default for RunOptions {
fn default() -> Self {
Self {
timeout: Duration::from_millis(100),
checkpoint_interval: 100,
max_call_depth: 128,
max_array_len: 0x100_0000,
providers: DEFAULT_RUNTIME_PROVIDERS.with(Clone::clone),
}
}
}
pub fn compile(source: &str) -> Result<MiraScript> {
compile_with(source, &CompileConfig::new())
}
pub fn compile_with(source: &str, config: &CompileConfig) -> Result<MiraScript> {
let (chunk, diagnostics) = core::Compiler::compile(source, config);
let chunk = chunk.ok_or_else(|| MiraError::compile(&diagnostics))?;
Ok(MiraScript {
id: ScriptId::new(),
program: Rc::new(Program::decode(&chunk)?),
})
}
#[doc(hidden)]
pub mod __private {
pub use crate::value::types::{
MiraField, shaped_array_from_array, shaped_array_from_record, shaped_record_from_array,
shaped_record_from_record,
};
}