dekopon-shell 0.84.0

Sandboxed bash-flavored script interpreter whose commands dispatch to Dekopon capabilities
Documentation
use std::{collections::HashSet, ops::Range};

use dekopon_process::{LimitExceeded, RetainedBytes};

use crate::{builtins::CommandFailure, limits::Budget};

pub(super) struct Ifs {
    delimiters: HashSet<char>,
    bytes: [bool; 256],
    _charge: RetainedBytes,
}

#[derive(Clone, Copy, Eq, PartialEq)]
pub(super) enum Kind {
    Text,
    LeadingByte,
    Whitespace,
    Delimiter,
}

#[derive(Clone, Copy, Eq, PartialEq)]
pub(super) enum Boundary {
    Start,
    ArrayStart,
    Text,
    Whitespace,
    Delimiter,
}

pub(super) enum Action {
    Append,
    Start,
    Empty,
    Separate,
}

impl Boundary {
    pub(super) fn accept(&mut self, kind: Kind) -> Action {
        match kind {
            Kind::Text | Kind::LeadingByte => {
                let action = match self {
                    Self::Text => Action::Append,
                    Self::Start | Self::ArrayStart | Self::Whitespace | Self::Delimiter => {
                        Action::Start
                    }
                };
                *self = Self::Text;
                action
            }
            Kind::Whitespace => {
                match self {
                    Self::Text | Self::ArrayStart => *self = Self::Whitespace,
                    Self::Start | Self::Whitespace | Self::Delimiter => {}
                }
                Action::Separate
            }
            Kind::Delimiter => {
                let action = match self {
                    Self::Start | Self::ArrayStart | Self::Delimiter => Action::Empty,
                    Self::Text | Self::Whitespace => Action::Separate,
                };
                *self = Self::Delimiter;
                action
            }
        }
    }
}

impl Ifs {
    pub(super) fn new(text: &str, budget: &Budget) -> Result<Self, LimitExceeded> {
        let charge = budget.charge_value_bytes((text.len() * 16) as u64)?;
        let mut bytes = [false; 256];
        for byte in text.bytes() {
            bytes[usize::from(byte)] = true;
        }
        Ok(Self {
            delimiters: text.chars().collect(),
            bytes,
            _charge: charge,
        })
    }

    pub(super) fn check_quoted(&self, text: &str) -> Result<(), CommandFailure> {
        for character in text.chars().filter(|character| !character.is_ascii()) {
            let mut encoded = [0; 4];
            if character
                .encode_utf8(&mut encoded)
                .bytes()
                .skip(1)
                .any(|byte| self.bytes[usize::from(byte)])
            {
                return Err(super::invalid_ifs_utf8());
            }
        }
        Ok(())
    }

    fn kind(&self, character: char) -> Kind {
        if !self.delimiters.contains(&character) {
            let mut encoded = [0; 4];
            if !character.is_ascii()
                && self.bytes[usize::from(character.encode_utf8(&mut encoded).as_bytes()[0])]
            {
                Kind::LeadingByte
            } else {
                Kind::Text
            }
        } else if matches!(character, ' ' | '\t' | '\n' | '\r' | '\u{b}' | '\u{c}') {
            Kind::Whitespace
        } else {
            Kind::Delimiter
        }
    }

    pub(super) fn contains(&self, character: char) -> bool {
        self.delimiters.contains(&character)
    }

    pub(super) fn byte_kind(&self, byte: u8) -> Kind {
        if self.bytes[usize::from(byte)] {
            Kind::Delimiter
        } else {
            Kind::Text
        }
    }

    pub(super) fn scan<'a>(
        &'a self,
        text: &'a str,
        protected: &'a [Range<usize>],
    ) -> impl Iterator<Item = (Kind, Range<usize>)> + 'a {
        let mut protected = protected.iter().peekable();
        let mut characters = text
            .char_indices()
            .flat_map(move |(offset, character)| {
                while protected.peek().is_some_and(|range| range.end <= offset) {
                    protected.next();
                }
                let quoted = protected
                    .peek()
                    .is_some_and(|range| range.contains(&offset));
                let mut spans: [Option<(Kind, Range<usize>)>; 4] = std::array::from_fn(|_| None);
                if quoted && !character.is_ascii() {
                    for (index, byte) in text.as_bytes()[offset..offset + character.len_utf8()]
                        .iter()
                        .enumerate()
                    {
                        let kind = if index > 0 && self.bytes[usize::from(*byte)] {
                            Kind::Delimiter
                        } else {
                            Kind::Text
                        };
                        spans[index] = Some((kind, offset + index..offset + index + 1));
                    }
                } else {
                    spans[0] = Some((
                        if quoted {
                            Kind::Text
                        } else {
                            self.kind(character)
                        },
                        offset..offset + character.len_utf8(),
                    ));
                }
                spans.into_iter().flatten()
            })
            .peekable();
        std::iter::from_fn(move || {
            let (kind, mut range) = characters.next()?;
            if matches!(kind, Kind::Text | Kind::Whitespace) {
                while characters.peek().is_some_and(|(next, _)| *next == kind) {
                    if let Some((_, next)) = characters.next() {
                        range.end = next.end;
                    }
                }
            }
            Some((kind, range))
        })
    }

    pub(super) fn read_fields(
        &self,
        text: &str,
        protected: &[Range<usize>],
        count: usize,
        budget: &mut Budget,
    ) -> Result<ReadFields, LimitExceeded> {
        let spans = self.scan(text, protected).flat_map(|(kind, range)| {
            let mut offset = range.start;
            std::iter::from_fn(move || {
                if offset == range.end {
                    return None;
                }
                let end = if kind == Kind::Whitespace {
                    offset + 1
                } else {
                    range.end
                };
                let span = (kind, offset..end);
                offset = end;
                Some(span)
            })
        });
        let mut cursor = ReadCursor {
            ifs: self,
            text,
            spans: spans.peekable(),
            continuation: None,
        };
        cursor.skip_whitespace(text, Whitespace::SpaceTabNewline);
        let mut ranges = Vec::new();
        let mut retained = budget.charge_value_bytes(0)?;
        for index in 0..count {
            let remainder = cursor.offset(text.len());
            let mut field = cursor.word(text);
            if index + 1 == count && cursor.offset(text.len()) < text.len() {
                let mut end = text.len();
                for (offset, character) in text.char_indices().rev() {
                    if !matches!(character, ' ' | '\t' | '\n')
                        || self.kind(character) != Kind::Whitespace
                    {
                        break;
                    }
                    end = offset;
                }
                field = remainder..end;
            }
            budget.charge_step()?;
            retained.grow(size_of::<Range<usize>>() as u64)?;
            ranges.push(field);
        }
        Ok(ReadFields {
            ranges,
            _charge: retained,
        })
    }
}

#[derive(Clone, Copy)]
enum Whitespace {
    All,
    SpaceTabNewline,
}

struct ReadCursor<'a, I: Iterator<Item = (Kind, Range<usize>)>> {
    ifs: &'a Ifs,
    text: &'a str,
    spans: std::iter::Peekable<I>,
    continuation: Option<Range<usize>>,
}

impl<I: Iterator<Item = (Kind, Range<usize>)>> ReadCursor<'_, I> {
    fn peek(&mut self) -> Option<(Kind, Range<usize>)> {
        self.continuation.as_ref().map_or_else(
            || self.spans.peek().cloned(),
            |range| {
                Some((
                    self.ifs.byte_kind(self.text.as_bytes()[range.start]),
                    range.start..range.start + 1,
                ))
            },
        )
    }

    fn consume(&mut self) {
        if let Some(range) = &mut self.continuation {
            range.start += 1;
            if range.start == range.end {
                self.continuation = None;
            }
        } else {
            self.spans.next();
        }
    }

    fn consume_byte(&mut self) {
        if self.continuation.is_some() {
            self.consume();
        } else if let Some((_, range)) = self.spans.next()
            && range.len() > 1
        {
            self.continuation = Some(range.start + 1..range.end);
        }
    }

    fn offset(&mut self, end: usize) -> usize {
        self.peek().map_or(end, |(_, range)| range.start)
    }

    fn skip_whitespace(&mut self, text: &str, whitespace: Whitespace) {
        while self.peek().is_some_and(|(kind, range)| {
            kind == Kind::Whitespace
                && match whitespace {
                    Whitespace::All => true,
                    Whitespace::SpaceTabNewline => {
                        matches!(text.as_bytes()[range.start], b' ' | b'\t' | b'\n')
                    }
                }
        }) {
            self.consume();
        }
    }

    fn word(&mut self, text: &str) -> Range<usize> {
        self.skip_whitespace(text, Whitespace::All);
        let start = self.offset(text.len());
        let mut end = start;
        while let Some((Kind::Text | Kind::LeadingByte, range)) = self.peek() {
            end = range.end;
            self.consume();
        }
        let whitespace = self
            .peek()
            .is_some_and(|(kind, _)| kind == Kind::Whitespace);
        self.consume();
        self.skip_whitespace(text, Whitespace::SpaceTabNewline);
        if whitespace
            && self
                .peek()
                .is_some_and(|(kind, _)| matches!(kind, Kind::Delimiter | Kind::LeadingByte))
        {
            // Bash consumes one byte here, even for a multibyte IFS character.
            self.consume_byte();
            self.skip_whitespace(text, Whitespace::All);
        }
        start..end
    }
}

pub(super) struct ReadFields {
    ranges: Vec<Range<usize>>,
    _charge: RetainedBytes,
}

impl ReadFields {
    pub(super) fn get<'a>(&self, text: &'a str, index: usize) -> Result<&'a str, CommandFailure> {
        match self.ranges.get(index) {
            None => Ok(""),
            Some(range) if range.is_empty() => Ok(""),
            Some(range) => text.get(range.clone()).ok_or_else(super::invalid_ifs_utf8),
        }
    }
}