crsn/crsn/src/asm/data/mod.rs

use std::convert::TryFrom;
use std::fmt::{Debug, Display, Formatter};
use std::fmt;

pub use mask::Mask;
pub use rd::Rd;
pub use rd::RdObj;
pub use reg::Register;
pub use wr::Wr;

use crate::asm::data::literal::{as_signed, Value};

use super::error::AsmError;

pub mod literal;
pub mod reg;
pub mod mask;

mod rd;

mod wr;

/// Data source disposition
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum DataDisp {
    /// Constant value
    Immediate(Value),
    /// Register
    Register(Register),
    /// Object pointer
    ObjectPtr(Register),
    /// Discard the written value
    Discard,
}

impl Display for DataDisp {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            DataDisp::Immediate(v) => {
                write!(f, "{}", as_signed(*v))
            }
            DataDisp::Register(r) => {
                write!(f, "{}", r)
            }
            DataDisp::ObjectPtr(r) => {
                write!(f, "@{}", r)
            }
            DataDisp::Discard => {
                write!(f, "_")
            }
        }
    }
}

impl From<RdData> for DataDisp {
    fn from(s: RdData) -> Self {
        match s {
            RdData::Immediate(x) => DataDisp::Immediate(x),
            RdData::Register(x) => DataDisp::Register(x),
            RdData::ObjectPtr(x) => DataDisp::ObjectPtr(x),
        }
    }
}

impl From<WrData> for DataDisp {
    fn from(s: WrData) -> Self {
        match s {
            WrData::Register(x) => DataDisp::Register(x),
            WrData::ObjectPtr(x) => DataDisp::ObjectPtr(x),
            WrData::Discard => DataDisp::Discard,
        }
    }
}

/// Data source disposition
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum RdData {
    /// Constant value
    Immediate(Value),
    /// Register
    Register(Register),
    /// Pointer into memory, stored in a numbered register
    ObjectPtr(Register),
}

impl TryFrom<DataDisp> for RdData {
    type Error = AsmError;

    fn try_from(value: DataDisp) -> Result<Self, Self::Error> {
        match value {
            DataDisp::Immediate(x) => Ok(RdData::Immediate(x)),
            DataDisp::Register(x) => Ok(RdData::Register(x)),
            DataDisp::ObjectPtr(x) => Ok(RdData::ObjectPtr(x)),
            DataDisp::Discard => Err(AsmError::DiscardAsValue),
        }
    }
}

/// Data destination disposition
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum WrData {
    /// Register
    Register(Register),
    /// Pointer into memory, stored in a numbered register
    ObjectPtr(Register),
    /// Discard the written value
    Discard,
}

impl From<WrData> for RdData {
    fn from(s: WrData) -> Self {
        match s {
            WrData::Register(x) => RdData::Register(x),
            WrData::ObjectPtr(x) => RdData::ObjectPtr(x),
            WrData::Discard => RdData::Immediate(0),
        }
    }
}

impl TryFrom<DataDisp> for WrData {
    type Error = AsmError;

    fn try_from(value: DataDisp) -> Result<Self, Self::Error> {
        match value {
            DataDisp::Immediate(_x) => Err(AsmError::ValueAsOutput),
            DataDisp::Register(x) => Ok(WrData::Register(x)),
            DataDisp::ObjectPtr(x) => Ok(WrData::ObjectPtr(x)),
            DataDisp::Discard => Ok(WrData::Discard),
        }
    }
}