148 lines
3.6 KiB
Rust
148 lines
3.6 KiB
Rust
//! 虚拟机栈实现
|
|
|
|
use thiserror::Error;
|
|
|
|
const MAX_STACK_SIZE: usize = 1024;
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum StackError {
|
|
#[error("栈溢出")]
|
|
Overflow,
|
|
#[error("栈下溢")]
|
|
Underflow,
|
|
}
|
|
|
|
/// 虚拟机栈
|
|
#[derive(Debug, Clone)]
|
|
pub struct Stack {
|
|
data: Vec<u64>,
|
|
max_size: usize,
|
|
}
|
|
|
|
impl Stack {
|
|
pub fn new() -> Self {
|
|
Stack {
|
|
data: Vec::new(),
|
|
max_size: MAX_STACK_SIZE,
|
|
}
|
|
}
|
|
|
|
pub fn with_capacity(capacity: usize) -> Self {
|
|
Stack {
|
|
data: Vec::with_capacity(capacity),
|
|
max_size: capacity,
|
|
}
|
|
}
|
|
|
|
/// 压栈
|
|
pub fn push(&mut self, value: u64) -> Result<(), StackError> {
|
|
if self.data.len() >= self.max_size {
|
|
return Err(StackError::Overflow);
|
|
}
|
|
self.data.push(value);
|
|
Ok(())
|
|
}
|
|
|
|
/// 出栈
|
|
pub fn pop(&mut self) -> Result<u64, StackError> {
|
|
self.data.pop().ok_or(StackError::Underflow)
|
|
}
|
|
|
|
/// 查看栈顶元素
|
|
pub fn peek(&self) -> Result<u64, StackError> {
|
|
self.data.last().copied().ok_or(StackError::Underflow)
|
|
}
|
|
|
|
/// 复制栈顶元素
|
|
pub fn dup(&mut self) -> Result<(), StackError> {
|
|
let value = self.peek()?;
|
|
self.push(value)
|
|
}
|
|
|
|
/// 交换栈顶两个元素
|
|
pub fn swap(&mut self) -> Result<(), StackError> {
|
|
if self.data.len() < 2 {
|
|
return Err(StackError::Underflow);
|
|
}
|
|
let len = self.data.len();
|
|
self.data.swap(len - 1, len - 2);
|
|
Ok(())
|
|
}
|
|
|
|
/// 获取栈大小
|
|
pub fn size(&self) -> usize {
|
|
self.data.len()
|
|
}
|
|
|
|
/// 检查栈是否为空
|
|
pub fn is_empty(&self) -> bool {
|
|
self.data.is_empty()
|
|
}
|
|
|
|
/// 清空栈
|
|
pub fn clear(&mut self) {
|
|
self.data.clear();
|
|
}
|
|
}
|
|
|
|
impl Default for Stack {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_stack_push_pop() {
|
|
let mut stack = Stack::new();
|
|
assert!(stack.push(42).is_ok());
|
|
assert!(stack.push(100).is_ok());
|
|
|
|
assert_eq!(stack.pop().expect("mainnet: handle error"), 100);
|
|
assert_eq!(stack.pop().expect("mainnet: handle error"), 42);
|
|
assert!(stack.pop().is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_stack_peek() {
|
|
let mut stack = Stack::new();
|
|
stack.push(42).expect("FIX-006: unexpected None/Err");
|
|
|
|
assert_eq!(stack.peek().expect("mainnet: handle error"), 42);
|
|
assert_eq!(stack.size(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn test_stack_dup() {
|
|
let mut stack = Stack::new();
|
|
stack.push(42).expect("FIX-006: unexpected None/Err");
|
|
stack.dup().expect("FIX-006: unexpected None/Err");
|
|
|
|
assert_eq!(stack.size(), 2);
|
|
assert_eq!(stack.pop().expect("mainnet: handle error"), 42);
|
|
assert_eq!(stack.pop().expect("mainnet: handle error"), 42);
|
|
}
|
|
|
|
#[test]
|
|
fn test_stack_swap() {
|
|
let mut stack = Stack::new();
|
|
stack.push(1).expect("FIX-006: unexpected None/Err");
|
|
stack.push(2).expect("FIX-006: unexpected None/Err");
|
|
stack.swap().expect("FIX-006: unexpected None/Err");
|
|
|
|
assert_eq!(stack.pop().expect("mainnet: handle error"), 1);
|
|
assert_eq!(stack.pop().expect("mainnet: handle error"), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn test_stack_overflow() {
|
|
let mut stack = Stack::with_capacity(2);
|
|
assert!(stack.push(1).is_ok());
|
|
assert!(stack.push(2).is_ok());
|
|
assert!(stack.push(3).is_err());
|
|
}
|
|
}
|