Alpha Chen
8 years ago
parent
1f51aca81c
commit
634179bac5
@ -0,0 +1,243 @@
|
||||
use std::collections::HashMap;
|
||||
use std::str;
|
||||
|
||||
use errors::*;
|
||||
|
||||
pub struct Assembunny {
|
||||
pub registers: HashMap<Register, isize>,
|
||||
pub instructions: Instructions,
|
||||
}
|
||||
|
||||
impl Assembunny {
|
||||
fn value<V: Into<Variable>>(&self, v: V) -> isize {
|
||||
let v: Variable = v.into();
|
||||
match v {
|
||||
Variable::Register(r) => {
|
||||
self.registers.get(&r).cloned().unwrap_or(0)
|
||||
}
|
||||
Variable::Value(i) => i,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Iterator for Assembunny {
|
||||
type Item = HashMap<Register, isize>;
|
||||
fn next(&mut self) -> Option<HashMap<Register, isize>> {
|
||||
let pc = self.value(Register::PC) as usize;
|
||||
let instruction = match self.instructions.0.get(pc) {
|
||||
Some(i) => i,
|
||||
None => {
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
match *instruction {
|
||||
Instruction::Cpy(v, r) => {
|
||||
let value = self.value(v);
|
||||
self.registers.insert(r, value);
|
||||
*self.registers.entry(Register::PC).or_insert(0) += 1;
|
||||
}
|
||||
Instruction::Inc(r) => {
|
||||
*self.registers.entry(r).or_insert(0) += 1;
|
||||
*self.registers.entry(Register::PC).or_insert(0) += 1;
|
||||
}
|
||||
Instruction::Dec(r) => {
|
||||
*self.registers.entry(r).or_insert(0) -= 1;
|
||||
*self.registers.entry(Register::PC).or_insert(0) += 1;
|
||||
}
|
||||
Instruction::Jnz(v, i) => {
|
||||
let delta = if self.value(v) == 0 { 1 } else { i };
|
||||
let pc = self.value(Register::PC) + delta;
|
||||
self.registers.insert(Register::PC, pc);
|
||||
}
|
||||
}
|
||||
|
||||
Some(self.registers.clone())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Instructions(Vec<Instruction>);
|
||||
|
||||
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)]
|
||||
pub enum Register {
|
||||
PC,
|
||||
A,
|
||||
B,
|
||||
C,
|
||||
D,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum Instruction {
|
||||
Cpy(Variable, Register),
|
||||
Inc(Register),
|
||||
Dec(Register),
|
||||
Jnz(Variable, isize),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum Variable {
|
||||
Register(Register),
|
||||
Value(isize),
|
||||
}
|
||||
|
||||
impl From<Register> for Variable {
|
||||
fn from(r: Register) -> Self {
|
||||
Variable::Register(r)
|
||||
}
|
||||
}
|
||||
|
||||
// Parsing
|
||||
|
||||
impl str::FromStr for Instructions {
|
||||
type Err = Error;
|
||||
fn from_str(s: &str) -> Result<Self> {
|
||||
s.lines()
|
||||
.map(|line| line.parse())
|
||||
.collect::<Result<Vec<_>>>()
|
||||
.map(Instructions)
|
||||
}
|
||||
}
|
||||
|
||||
impl str::FromStr for Register {
|
||||
type Err = Error;
|
||||
fn from_str(s: &str) -> Result<Self> {
|
||||
match s {
|
||||
"a" => Ok(Register::A),
|
||||
"b" => Ok(Register::B),
|
||||
"c" => Ok(Register::C),
|
||||
"d" => Ok(Register::D),
|
||||
_ => Err(format!("invalid register '{}'", s).into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl str::FromStr for Instruction {
|
||||
type Err = Error;
|
||||
fn from_str(s: &str) -> Result<Self> {
|
||||
let mut tokens = s.split_whitespace();
|
||||
match tokens.next() {
|
||||
Some("cpy") => {
|
||||
let v = tokens.read_variable()?;
|
||||
let r = tokens.read_register()?;
|
||||
Ok(Instruction::Cpy(v, r))
|
||||
}
|
||||
Some("inc") => {
|
||||
let r = tokens.read_register()?;
|
||||
Ok(Instruction::Inc(r))
|
||||
}
|
||||
Some("dec") => {
|
||||
let r = tokens.read_register()?;
|
||||
Ok(Instruction::Dec(r))
|
||||
}
|
||||
Some("jnz") => {
|
||||
let var = tokens.read_variable()?;
|
||||
let val = tokens.read_value()?;
|
||||
Ok(Instruction::Jnz(var, val))
|
||||
}
|
||||
Some(inst) => Err(format!("invalid instruction '{}'", inst).into()),
|
||||
None => Err("no instruction".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl str::FromStr for Variable {
|
||||
type Err = Error;
|
||||
fn from_str(s: &str) -> Result<Self> {
|
||||
s.parse::<Register>()
|
||||
.map(Variable::Register)
|
||||
.or_else(|_| s.parse::<isize>().map(Variable::Value))
|
||||
.map_err(|_| format!("invalid variable '{}'", s).into())
|
||||
}
|
||||
}
|
||||
|
||||
trait SplitWhitespaceExt {
|
||||
fn read_variable(&mut self) -> Result<Variable>;
|
||||
fn read_register(&mut self) -> Result<Register>;
|
||||
fn read_value(&mut self) -> Result<isize>;
|
||||
}
|
||||
|
||||
impl<'a> SplitWhitespaceExt for str::SplitWhitespace<'a> {
|
||||
fn read_variable(&mut self) -> Result<Variable> {
|
||||
self.next()
|
||||
.ok_or("missing variable".into())
|
||||
.and_then(|v| v.parse::<Variable>())
|
||||
}
|
||||
|
||||
fn read_register(&mut self) -> Result<Register> {
|
||||
self.next()
|
||||
.ok_or("missing register".into())
|
||||
.and_then(|v| v.parse::<Register>())
|
||||
}
|
||||
|
||||
fn read_value(&mut self) -> Result<isize> {
|
||||
self.next()
|
||||
.ok_or("missing value".into())
|
||||
.and_then(|v| v.parse::<isize>().chain_err(|| ""))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{Assembunny, Instructions, Instruction, Register, Variable};
|
||||
use std::collections::HashMap;
|
||||
use std::str::FromStr;
|
||||
|
||||
#[test]
|
||||
fn test_assembunny() {
|
||||
let instructions: Instructions = "cpy 41 a
|
||||
inc a
|
||||
inc a
|
||||
dec a
|
||||
jnz a 2
|
||||
dec a"
|
||||
.parse()
|
||||
.unwrap();
|
||||
let mut assembunny = Assembunny {
|
||||
registers: HashMap::new(),
|
||||
instructions: instructions,
|
||||
};
|
||||
|
||||
let registers = assembunny.next().unwrap();
|
||||
assert_eq!(registers.get(&Register::A), Some(&41));
|
||||
assert_eq!(registers.get(&Register::B), None);
|
||||
|
||||
let registers = assembunny.next().unwrap();
|
||||
assert_eq!(registers.get(&Register::A), Some(&42));
|
||||
assert_eq!(registers.get(&Register::C), None);
|
||||
|
||||
let registers = assembunny.last().unwrap();
|
||||
assert_eq!(registers.get(&Register::A), Some(&42));
|
||||
assert_eq!(registers.get(&Register::PC), Some(&6));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_instructions_from_str() {
|
||||
let i: Instructions = "cpy 41 a
|
||||
inc a
|
||||
inc a
|
||||
dec a
|
||||
jnz a 2
|
||||
dec a"
|
||||
.parse()
|
||||
.unwrap();
|
||||
assert_eq!(i.0.len(), 6);
|
||||
assert_eq!(i.0[0], Instruction::from_str("cpy 41 a").unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_instruction_from_str() {
|
||||
assert!(Instruction::from_str("").is_err());
|
||||
assert!(Instruction::from_str("omg").is_err());
|
||||
assert!(Instruction::from_str("inc 5").is_err());
|
||||
|
||||
assert_eq!(Instruction::from_str("cpy 41 a").unwrap(),
|
||||
Instruction::Cpy(Variable::Value(41), Register::A));
|
||||
assert_eq!(Instruction::from_str("inc a").unwrap(),
|
||||
Instruction::Inc(Register::A));
|
||||
assert_eq!(Instruction::from_str("dec b").unwrap(),
|
||||
Instruction::Dec(Register::B));
|
||||
assert_eq!(Instruction::from_str("jnz c 2").unwrap(),
|
||||
Instruction::Jnz(Variable::Register(Register::C), 2));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue