crsn/crsn/src/module/mod.rs

#![allow(unused_variables)]

use std::fmt::Debug;

pub use eval_res::EvalRes;

use crate::asm::data::literal::Value;
use crate::asm::data::Mask;
use crate::asm::error::CrsnError;
use crate::asm::instr::Flatten;
use crate::asm::instr::op::OpKind;
use crate::asm::parse::arg_parser::TokenParser;
use crate::runtime::fault::Fault;
use crate::runtime::run_thread::state::RunState;
use crate::runtime::run_thread::ThreadInfo;

mod eval_res;

/// Result type returned from the op parser. This is the Ok variant of a Result.
pub enum ParseRes<'a, T> {
    /// Parsing successful.
    Parsed(T),
    /// Parsing successful, but did not yield any result
    ParsedNone,
    /// Instruction not recognized, but there was no error.
    Unknown(TokenParser<'a>),
}

impl<'a> ParseRes<'a, OpKind> {
    /// Helper to construct an extension op
    pub fn ext(op: impl OpTrait) -> Self {
        Self::Parsed(OpKind::Ext(Box::new(op)))
    }
}

pub trait OpTrait: Debug + Send + Sync + 'static {
    fn execute(&self, ti: &ThreadInfo, state: &mut RunState) -> Result<EvalRes, Fault>;
}

pub trait CrsnExtension: Debug + Send + Sync + 'static {
    /// Get name of the module
    fn name(&self) -> &'static str;

    /// Parse an op.
    /// If the keyword matches and the function decides to parse the instruction, it must consume
    /// the argument list and either return Ok or Err.
    ///
    /// If the instruction keyword is not recognized, return Unknown with the unchanged argument list.
    ///
    /// pcx is available on the arg_tokens parser
    fn parse_op<'a>(&self, keyword: &str, arg_tokens: TokenParser<'a>) -> Result<ParseRes<'a, OpKind>, CrsnError>;

    /// Parse a generic S-expression (non-op)
    ///
    /// pcx is available on the arg_tokens parser
    fn parse_syntax<'a>(&self, keyword: &str, tokens: TokenParser<'a>)
                        -> Result<ParseRes<'a, Box<dyn Flatten>>, CrsnError>
    {
        Ok(ParseRes::Unknown(tokens))
    }

    /// Drop an object referenced by a handle
    fn drop_obj(&self, ti: &ThreadInfo, state: &mut RunState, handle: Value)
                -> Result<Option<()>, Fault>
    {
        // Default impl - we do not support dropping this object
        Ok(None)
    }

    /// Run-time method called to read an object (using the object handle syntax)
    fn read_obj(&self, ti: &ThreadInfo, state: &mut RunState, handle: Value, _mask: Mask)
                -> Result<Option<Value>, Fault>
    {
        // Default impl - we do not support reading this object
        Ok(None)
    }

    /// Run-time method called to write an object (using the object handle syntax)
    fn write_obj(&self, ti: &ThreadInfo, state: &mut RunState, handle: Value, mask: Mask)
                 -> Result<Option<()>, Fault>
    {
        // Default impl - we do not support writing this object
        Ok(None)
    }
}