path: root/src/types/expression_stack.rs

use crate::*;


pub struct ExpressionStack {
    stack: Vec<IntermediateValue>,
}

impl ExpressionStack {
    pub fn new() -> Self {
        Self {
            stack: Vec::new(),
        }
    }

    pub fn pull_result(mut self) -> Result<isize, ExpressionError> {
        match self.stack.len() {
            0 => Err(ExpressionError::NoReturnValue),
            1 => {
                match self.stack.pop().unwrap() {
                    IntermediateValue::Integer(value) => Ok(*value),
                    IntermediateValue::List(_) => Err(ExpressionError::InvalidReturnType("a list")),
                    IntermediateValue::Block(_) => Err(ExpressionError::InvalidReturnType("a block")),
                }
            }
            _ => Err(ExpressionError::MultipleReturnValues),
        }
    }

    pub fn push(&mut self, value: IntermediateValue) {
        self.stack.push(value);
    }

    pub fn apply(&mut self, operator: Operator, source: &SourceSpan) -> Result<(), Tracked<ExpressionError>> {
        macro_rules! push {
            ($res:expr) => {
                match $res {
                    Ok(value) => self.stack.push(value),
                    Err(error) => return Err(Tracked::from(error, source.clone())),
                }
            }
        }
        macro_rules! pop {
            ($name:ident) => {
                let $name = match self.stack.pop() {
                    Some(value) => value,
                    None => return Err(Tracked::from(ExpressionError::Underflow, source.clone())),
                };
            }
        }

        match operator {
            Operator::Equal            => { pop!(b); pop!(a); push!(op_equal(a, b)) },
            Operator::NotEqual         => { pop!(b); pop!(a); push!(op_not_equal(a, b)) },
            Operator::LessThan         => { pop!(b); pop!(a); push!(op_less_than(a, b)) },
            Operator::GreaterThan      => { pop!(b); pop!(a); push!(op_greater_than(a, b)) },
            Operator::LessThanEqual    => { pop!(b); pop!(a); push!(op_less_than_equal(a, b)) },
            Operator::GreaterThanEqual => { pop!(b); pop!(a); push!(op_greater_than_equal(a, b)) },
            Operator::Add              => { pop!(b); pop!(a); push!(op_add(a, b)) },
            Operator::Subtract         => { pop!(b); pop!(a); push!(op_subtract(a, b)) },
            Operator::Multiply         => { pop!(b); pop!(a); push!(op_multiply(a, b)) },
            Operator::Divide           => { pop!(b); pop!(a); push!(op_divide(a, b)) },
            Operator::Modulo           => { pop!(b); pop!(a); push!(op_modulo(a, b)) },
            Operator::Exponent         => { pop!(b); pop!(a); push!(op_exponent(a, b)) },
            Operator::LeftShift        => { pop!(b); pop!(a); push!(op_left_shift(a, b)) },
            Operator::RightShift       => { pop!(b); pop!(a); push!(op_right_shift(a, b)) },
            Operator::BitAnd           => { pop!(b); pop!(a); push!(op_bit_and(a, b)) },
            Operator::BitOr            => { pop!(b); pop!(a); push!(op_bit_or(a, b)) },
            Operator::BitXor           => { pop!(b); pop!(a); push!(op_bit_xor(a, b)) },
            Operator::BitNot           => {          pop!(a); push!(op_bit_not(a)) },
            Operator::Length           => {          pop!(a); push!(op_length(a)) },
            Operator::Index            => { pop!(b); pop!(a); push!(op_index(a, b)) },
            Operator::Find             => { pop!(b); pop!(a); push!(op_find(a, b)) },
            Operator::Sum              => {          pop!(a); push!(op_sum(a)) },
            Operator::Absolute         => {          pop!(a); push!(op_absolute(a)) },
            Operator::Debug            => {          op_debug(&self.stack, &source); },
        }
        return Ok(());
    }
}

// Generate fake tracking information for synthetic values.
fn null_span() -> SourceSpan {
    SourceSpan {
        string: String::new(),
        in_merged: SourceLocation {
            path: None,
            start: SourcePosition { line: 0, column: 0 },
            end: SourcePosition { line: 0, column: 0 },
        },
        in_source: None,
        child: None,
    }
}

fn to_isize(value: IntermediateValue) -> Result<isize, ExpressionError> {
    let received = match value {
        IntermediateValue::Integer(integer) => return Ok(integer.value),
        IntermediateValue::List(_) => "a list",
        IntermediateValue::Block(_) => "a block",
    };
    Err(ExpressionError::InvalidArgumentType("an integer", received))
}

fn to_list(value: IntermediateValue) -> Result<Vec<isize>, ExpressionError> {
    let received = match value {
        IntermediateValue::List(list) => return Ok(list.into_iter().map(|t| t.value).collect()),
        IntermediateValue::Integer(_) => "an integer",
        IntermediateValue::Block(_) => "a block",
    };
    Err(ExpressionError::InvalidArgumentType("a list", received))
}

fn from_isize(value: isize) -> IntermediateValue {
    IntermediateValue::Integer(Tracked::from(value, null_span()))
}

fn from_bool(value: bool) -> IntermediateValue {
    // Source span isn't used by anything.
    match value {
        true => IntermediateValue::Integer(Tracked::from(1, null_span())),
        false => IntermediateValue::Integer(Tracked::from(0, null_span())),
    }
}

fn op_equal(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_bool(to_isize(l)? == to_isize(r)?))  }
fn op_not_equal(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_bool(to_isize(l)? != to_isize(r)?))  }
fn op_less_than(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_bool(to_isize(l)? < to_isize(r)?))  }
fn op_greater_than(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_bool(to_isize(l)? > to_isize(r)?))  }
fn op_less_than_equal(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_bool(to_isize(l)? <= to_isize(r)?))  }
fn op_greater_than_equal(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_bool(to_isize(l)? >= to_isize(r)?))  }
fn op_add(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize(to_isize(l)? + to_isize(r)?))  }
fn op_subtract(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize(to_isize(l)? - to_isize(r)?))  }
fn op_multiply(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize(to_isize(l)? * to_isize(r)?))  }
fn op_divide(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_isize(l)?; let r = to_isize(r)?;
    match r != 0 {
        true => Ok(from_isize(l / r)),
        false => Ok(from_isize(0)),
    }
}
fn op_modulo(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_isize(l)?; let r = to_isize(r)?;
    match r != 0 {
        true => Ok(from_isize(l % r)),
        false => Ok(from_isize(0)),
    }
}
fn op_exponent(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_isize(l)?; let r = to_isize(r)?;
    if let Ok(r) = u32::try_from(r) {
        Ok(from_isize(l.saturating_pow(r)))
    } else {
        Ok(from_isize(0))
    }
}
fn op_left_shift(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_isize(l)?; let r = to_isize(r)?;
    Ok(from_isize(if r < 0 { l >> -r } else { l << r }))
}
fn op_right_shift(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_isize(l)?; let r = to_isize(r)?;
    Ok(from_isize(if r < 0 { l << -r } else { l >> r }))
}
fn op_bit_and(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize((to_isize(l)?) & (to_isize(r)?)))  }
fn op_bit_or(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize((to_isize(l)?) | (to_isize(r)?)))  }
fn op_bit_xor(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize((to_isize(l)?) ^ (to_isize(r)?)))  }
fn op_bit_not(l: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize(!to_isize(l)?))  }
fn op_length(l: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let length = match l {
        IntermediateValue::Integer(integer) => width(*integer) as isize,
        IntermediateValue::List(list) => list.len() as isize,
        IntermediateValue::Block(block) => block.len() as isize,
    };
    Ok(from_isize(length))
}
fn op_index(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_list(l)?; let r = to_isize(r)?;
    match r >= 0 && r < l.len() as isize {
        true => Ok(from_isize(l[r as usize])),
        false => Err(ExpressionError::IndexError(l.len(), r)),
    }
}
fn op_find(l: IntermediateValue, r: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let l = to_list(l)?; let r = to_isize(r)?;
    match l.iter().position(|e| *e == r) {
        Some(i) => Ok(from_isize(i as isize)),
        None => Err(ExpressionError::FindError(l.len(), r)),
    }
}
fn op_sum(l: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    let sum = match l {
        IntermediateValue::Integer(integer) => ones(*integer) as isize,
        IntermediateValue::List(list) => list.into_iter().map(|t| t.value).sum(),
        IntermediateValue::Block(_) => return Err(ExpressionError::InvalidArgumentType("an integer or list", "a block"))
    };
    Ok(from_isize(sum))
}
fn op_absolute(l: IntermediateValue) -> Result<IntermediateValue, ExpressionError> {
    Ok(from_isize(to_isize(l)?.wrapping_abs()))  }
fn op_debug(stack: &Vec<IntermediateValue>, source: &SourceSpan) {
    let mut output = String::new();
    for value in stack.iter().rev() {
        let string = match value {
            IntermediateValue::Integer(integer) =>
                integer.to_string(),
            IntermediateValue::List(list) => {
                let strings: Vec<String> = list.iter().map(|t| t.value.to_string()).collect();
                format!("[{}]", strings.join(" "))
            }
            IntermediateValue::Block(_) => unreachable!("Block value in expression"),
        };
        output.push_str(&format!("    --> {string}\n"));
    }
    let len = stack.len();
    let element = if len == 1 { "element" } else { "elements" };
    let message = format!("Printing expression stack with {len} {element} at {}", source.location());
    log_info(&message, Some(output));
}


/// Find the number of bits required to hold an integer.
pub fn width(value: isize) -> u32 {
    match value.cmp(&0) {
        std::cmp::Ordering::Less => (-value).ilog2() + 2,
        std::cmp::Ordering::Equal => 0,
        std::cmp::Ordering::Greater => value.ilog2() + 1,
    }
}

/// Count the number of one bits in a value.
pub fn ones(value: isize) -> u32 {
    let width = width(value);
    let mask = 2i32.pow(width) -1;
    let value = (value as usize) & (mask as usize);
    return value.count_ones();
}

pub enum ExpressionError {
    Underflow,
    MultipleReturnValues,
    NoReturnValue,
    InvalidReturnType(&'static str),
    // (expected, received)
    InvalidArgumentType(&'static str, &'static str),
    // (length, index)
    IndexError(usize, isize),
    // (length, value)
    FindError(usize, isize),
}


pub fn report_expression_error(error: &Tracked<ExpressionError>, source_code: &str) {
    let context = Context { source_code: &source_code, source: &error.source };
    let message = match &error.value {
        ExpressionError::Underflow =>
            "A stack underflow occurred while evaluating this operator",
        ExpressionError::MultipleReturnValues =>
            "More than one value was left on the stack after this expression was evaluated",
        ExpressionError::NoReturnValue =>
            "No value was left on the stack after this expression was evaluated",
        ExpressionError::InvalidReturnType(received) =>
            &format!("Expression must return an integer value, not {received} value"),
        ExpressionError::InvalidArgumentType(expected, received) =>
            &format!("Operator expected {expected} value, not {received} value"),
        ExpressionError::IndexError(length, index) =>
            &format!("Could not access element {index} from a list of length {length}"),
        ExpressionError::FindError(length, value) => {
            let mut character = String::new();
            if let Ok(value) = u32::try_from(*value) {
                if let Some(c) = char::from_u32(value) {
                    character = format!(" (character '{c}')");
                }
            }
            &format!("Could not find value {value}{character} in list of length {length}")
        }
    };

    report_source_issue(LogLevel::Error, &context, message);
}