You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
85 lines
2.8 KiB
85 lines
2.8 KiB
#![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)
|
|
}
|
|
}
|
|
|