#![doc = include_str!("../README.md")]
#![warn(missing_docs)]
extern crate self as mirascript_vm;
mod bytecode;
mod context;
mod error;
mod interpreter;
mod operations;
mod standard_library;
mod value;
use std::rc::Rc;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
pub use context::MiraContext;
pub use error::{MiraError, Result};
pub use mirascript_core as core;
pub use mirascript_vm_derive::{MiraArray, MiraExtern, MiraRecord};
pub use value::{
MiraAny, MiraArray, MiraCallContext, MiraExtern, MiraFunction, MiraModule, MiraNativeFn,
MiraRecord, MiraShared,
};
#[doc(hidden)]
pub mod __private {
pub use crate::value::MiraBridge;
}
use bytecode::Program;
#[derive(Clone)]
pub struct MiraScript {
program: Program,
}
#[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, &core::Config::new())
}
pub fn compile_with(source: &str, config: &core::Config) -> Result<MiraScript> {
let (chunk, diagnostics) = core::Compiler::compile(source, config);
let chunk = chunk.ok_or(MiraError::Compile { diagnostics })?;
Ok(MiraScript {
program: Program::decode(&chunk)?,
})
}
pub fn eval(source: &str, context: &MiraContext) -> Result<MiraAny> {
compile(source)?.run(context)
}
impl MiraScript {
pub fn run(&self, context: &MiraContext) -> Result<MiraAny> {
self.run_with(context, &RunOptions::default())
}
pub fn run_with(&self, context: &MiraContext, options: &RunOptions) -> Result<MiraAny> {
interpreter::run(&self.program, context, options)
}
}