mirascript-vm 0.1.87

Native Rust virtual machine for MiraScript
Documentation
use super::*;

pub(crate) fn to_boolean(value: &MiraAny) -> Result<bool> {
    assert_initialized(value)?;
    match value {
        MiraAny::Boolean(value) => Ok(*value),
        _ => Err(MiraError::runtime(format!(
            "Failed to convert value to boolean: {}",
            display(value)
        ))),
    }
}

pub(crate) fn to_number(value: &MiraAny) -> Result<f64> {
    assert_initialized(value)?;
    match value {
        MiraAny::Number(value) => Ok(*value),
        MiraAny::Boolean(value) => Ok(if *value { 1.0 } else { 0.0 }),
        MiraAny::String(value) => parse_number(value).ok_or_else(|| {
            MiraError::runtime(format!(
                "Failed to convert value to number: {}",
                display(&MiraAny::String(value.clone()))
            ))
        }),
        _ => Err(MiraError::runtime(format!(
            "Failed to convert value to number: {}",
            display(value)
        ))),
    }
}

fn parse_number(value: &str) -> Option<f64> {
    let value = value.trim();
    if value.is_empty() {
        return None;
    }
    match value {
        "inf" | "+inf" | "Infinity" | "+Infinity" => return Some(f64::INFINITY),
        "-inf" | "-Infinity" => return Some(f64::NEG_INFINITY),
        "nan" | "NaN" => return Some(f64::NAN),
        _ => {}
    }
    let (sign, unsigned) = if let Some(value) = value.strip_prefix('-') {
        (-1.0, value)
    } else if let Some(value) = value.strip_prefix('+') {
        (1.0, value)
    } else {
        (1.0, value)
    };
    if unsigned.is_empty() || !unsigned.as_bytes()[0].is_ascii_digit() {
        return None;
    }
    let parsed = if let Some(value) = unsigned
        .strip_prefix("0b")
        .or_else(|| unsigned.strip_prefix("0B"))
    {
        if value.is_empty() || !value.bytes().all(|byte| matches!(byte, b'0' | b'1')) {
            return None;
        }
        u64::from_str_radix(value, 2).ok().map(|value| value as f64)
    } else if let Some(value) = unsigned
        .strip_prefix("0o")
        .or_else(|| unsigned.strip_prefix("0O"))
    {
        if value.is_empty() || !value.bytes().all(|byte| matches!(byte, b'0'..=b'7')) {
            return None;
        }
        u64::from_str_radix(value, 8).ok().map(|value| value as f64)
    } else if let Some(value) = unsigned
        .strip_prefix("0x")
        .or_else(|| unsigned.strip_prefix("0X"))
    {
        if value.is_empty() || !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
            return None;
        }
        u64::from_str_radix(value, 16)
            .ok()
            .map(|value| value as f64)
    } else if valid_decimal(unsigned) {
        unsigned.parse::<f64>().ok()
    } else {
        None
    }?;
    Some(sign * parsed)
}

fn valid_decimal(value: &str) -> bool {
    let bytes = value.as_bytes();
    let mut index = 0;
    while index < bytes.len() && bytes[index].is_ascii_digit() {
        index += 1;
    }
    if index < bytes.len() && bytes[index] == b'.' {
        index += 1;
        let fraction = index;
        while index < bytes.len() && bytes[index].is_ascii_digit() {
            index += 1;
        }
        if index == fraction {
            return false;
        }
    }
    if index < bytes.len() && matches!(bytes[index], b'e' | b'E') {
        index += 1;
        if index < bytes.len() && matches!(bytes[index], b'+' | b'-') {
            index += 1;
        }
        let exponent = index;
        while index < bytes.len() && bytes[index].is_ascii_digit() {
            index += 1;
        }
        if index == exponent {
            return false;
        }
    }
    index == bytes.len()
}

pub(crate) fn number_to_string(value: f64, minus_zero: bool) -> String {
    if value.is_nan() {
        return "nan".into();
    }
    if value == f64::INFINITY {
        return "inf".into();
    }
    if value == f64::NEG_INFINITY {
        return "-inf".into();
    }
    if value == 0.0 {
        if minus_zero && value.is_sign_negative() {
            return "-0".into();
        }
        return "0".into();
    }
    if value.abs() >= 1e21 || value.abs() < 1e-6 {
        return javascript_exponent(format!("{value:e}"));
    }
    value.to_string()
}

pub(crate) fn to_string(value: &MiraAny) -> Result<String> {
    assert_initialized(value)?;
    match value {
        MiraAny::String(value) => Ok(value.clone()),
        MiraAny::Nil => Ok(String::new()),
        value => inner_to_string(value, false),
    }
}

pub(super) fn inner_to_string(value: &MiraAny, braces: bool) -> Result<String> {
    match value {
        MiraAny::Uninitialized | MiraAny::Nil => Ok("nil".into()),
        MiraAny::Boolean(value) => Ok(value.to_string()),
        MiraAny::Number(value) => Ok(number_to_string(*value, false)),
        MiraAny::String(value) => Ok(value.clone()),
        MiraAny::Function(function) => Ok(match function.name() {
            Some(name) => format!("<function {name}>"),
            None => "<function>".into(),
        }),
        MiraAny::Module(module) => Ok(format!("<module {}>", module.name())),
        MiraAny::Extern(value) => Ok(format!("<extern {}>", value.tag()?)),
        MiraAny::Array(_) | MiraAny::RustArray(_) => {
            let length = value.array_len()?.unwrap_or(0);
            let mut parts = Vec::with_capacity(length);
            for index in 0..length {
                parts.push(inner_to_string(
                    &value.array_get(index)?.unwrap_or(MiraAny::Nil),
                    true,
                )?);
            }
            let body = parts.join(", ");
            Ok(if braces { format!("[{body}]") } else { body })
        }
        MiraAny::Record(_) | MiraAny::RustRecord(_) => {
            let mut parts = Vec::new();
            for key in value.record_keys()?.unwrap_or_default() {
                let item = value.record_get(&key)?.unwrap_or(MiraAny::Nil);
                parts.push(format!("{key}: {}", inner_to_string(&item, true)?));
            }
            let body = parts.join(", ");
            Ok(if braces { format!("({body})") } else { body })
        }
    }
}