crsn/crsn_stacks/src/exec.rs

use std::collections::VecDeque;

use crsn::asm::data::literal::Value;
use crsn::asm::instr::Cond;
use crsn::module::{EvalRes, OpTrait};
use crsn::runtime::fault::Fault;
use crsn::runtime::run_thread::{state::RunState, ThreadInfo};

use crate::defs::StackOp;

struct Stacks {
    stacks: Vec<VecDeque<Value>>,
}

impl Default for Stacks {
    fn default() -> Self {
        Stacks {
            stacks: vec![VecDeque::default(); 8],
        }
    }
}

impl OpTrait for StackOp {
    fn execute(&self, _ti: &ThreadInfo, state: &mut RunState) -> Result<EvalRes, Fault> {
        let eres = EvalRes::default();
        match self {
            StackOp::Push { num, src } => {
                state.clear_status();
                let stack_num = state.read(*num)?;
                let val = state.read(*src)?;

                if stack_num > 8 {
                    state.set_flag(Cond::Invalid, true);
                } else {
                    let obj: &mut Stacks = state.ext_mut();
                    obj.stacks[stack_num as usize].push_back(val);
                }
            }
            StackOp::Pop { dst, num } => {
                state.clear_status();
                let stack_num = state.read(*num)?;

                if stack_num > 8 {
                    state.set_flag(Cond::Invalid, true);
                } else {
                    let obj: &mut Stacks = state.ext_mut();
                    let val = obj.stacks[stack_num as usize].pop_back();

                    if obj.stacks[stack_num as usize].is_empty() {
                        state.set_flag(Cond::Zero, true);
                    }

                    let val = match val {
                        None => {
                            state.set_flag(Cond::Overflow, true);
                            0
                        }
                        Some(val) => {
                            val
                        }
                    };

                    state.write(*dst, val)?;
                }

                // TODO
            }
        }

        Ok(eres)
    }
    //
}