dekopon-shell 0.66.0

Sandboxed bash-flavored script interpreter whose commands dispatch to Dekopon capabilities
Documentation
mod lex;
mod parse;
#[cfg(test)]
mod tests;

use crate::{builtins::CommandFailure, limits::Budget};
use dekopon_process::{LimitExceeded, RetainedBytes, ShellThreads, ThreadName};
use parse::{Program, Refusal};
use regex_bites::Regex;

#[derive(Debug, PartialEq)]
enum AwkError {
    Refused(Refusal),
    Syntax {
        line: usize,
        column: usize,
        expected: String,
    },
    Runtime(RuntimeError),
    Limit(LimitExceeded),
}

#[derive(Debug, PartialEq)]
struct RuntimeError {
    refusal: Refusal,
    record: f64,
}

impl From<Refusal> for AwkError {
    fn from(value: Refusal) -> Self {
        Self::Refused(value)
    }
}
impl From<LimitExceeded> for AwkError {
    fn from(value: LimitExceeded) -> Self {
        Self::Limit(value)
    }
}
impl From<AwkError> for CommandFailure {
    fn from(value: AwkError) -> Self {
        match value {
            AwkError::Refused(refusal) => Self::usage(refusal.message()),
            AwkError::Syntax {
                line,
                column,
                expected,
            } => Self::usage(format!(
                "awk: syntax error at line {line}, column {column}: {expected}"
            )),
            AwkError::Runtime(RuntimeError { refusal, record }) => {
                Self::usage(format!("{} (record {record})", refusal.message()))
            }
            AwkError::Limit(limit) => limit.into(),
        }
    }
}

#[derive(Debug)]
struct Compiled {
    program: Program,
    regexes: Vec<ChargedRegex>,
}

#[derive(Debug)]
struct ChargedRegex {
    regex: Regex,
    _charge: RetainedBytes,
}

impl ChargedRegex {
    fn compile(source: &str, budget: &Budget) -> Result<Self, AwkError> {
        crate::builtins::text::check_extended_length("awk", source).map_err(Refusal::Regex)?;
        let charge = budget.charge_value_bytes(256 * 1024)?;
        let rewritten = lex::rewrite_regex(source)?;
        let regex = crate::builtins::text::build_extended("awk", &rewritten, source, false)
            .map_err(Refusal::Regex)?;
        if regex.captures_len() != 1 {
            return Err(Refusal::InternalRegex.into());
        }
        Ok(Self {
            regex,
            _charge: charge,
        })
    }
}

fn compile(source: &str, budget: &Budget) -> Result<Compiled, AwkError> {
    if source.len() > 8192 {
        return Err(Refusal::ProgramBytes(source.len()).into());
    }
    let stack = budget.charge_value_bytes(ShellThreads::STACK_BYTES as u64)?;
    let [permit] = budget.tree().shell_threads().reserve()?;
    #[expect(
        clippy::disallowed_methods,
        reason = "owner: compile joins the parser; bound: one admitted thread and a charged 2 MiB stack"
    )]
    let parsed = std::thread::scope(|scope| {
        let parser = permit
            .spawn(scope, ThreadName::new("awk-parse"), || {
                parse::program(source)
            })
            .map_err(|error| Refusal::ParserStart(error.to_string()))?;
        parser.join().map_err(|panic| {
            let reason = panic
                .downcast_ref::<String>()
                .map(String::as_str)
                .or_else(|| panic.downcast_ref::<&str>().copied())
                .unwrap_or("non-string panic payload");
            AwkError::Refused(Refusal::ParserPanic(reason.to_owned()))
        })?
    });
    drop(stack);
    let program = parsed?;
    let regexes = program
        .regex_sources
        .iter()
        .map(|source| ChargedRegex::compile(source, budget))
        .collect::<Result<_, _>>()?;
    Ok(Compiled { program, regexes })
}