guilhermewerner/machine
1
0
Fork 0
mirror of https://github.com/guilhermewerner/machine synced 2025-06-20 15:04:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update machine methods

Browse Source
This commit is contained in:
Werner
2021-11-16 12:15:05 -03:00
parent 92576fbdd3
commit ef313c8f66
5 changed files with 375 additions and 265 deletions

348
Source/Instructions.rs

@ -1,326 +1,402 @@
use crate::Machine;
pub fn Nothing(vm: &mut Machine) -> bool {
vm.program += 1;
vm.WalkAddress(1);
false
}
pub fn LoadRegister(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1];
let a = vm.memory[vm.program + 2];
let pc = vm.GetAddress();
vm.registers[r as usize] = vm.memory[a as usize];
let reg = vm.GetMemory(pc + 1);
let addr = vm.GetMemory(pc + 2);
vm.program += 3;
let val = vm.GetMemory(addr);
vm.SetRegister(reg, val);
vm.WalkAddress(3);
true
}
pub fn SaveRegister(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1];
let a = vm.memory[vm.program + 2];
let pc = vm.GetAddress();
vm.memory[a as usize] = vm.registers[r as usize];
let addr = vm.GetMemory(pc + 1);
let reg = vm.GetMemory(pc + 2);
vm.program += 3;
let val = vm.GetRegister(reg);
vm.SetMemory(addr, val);
vm.WalkAddress(3);
true
}
pub fn Move(vm: &mut Machine) -> bool {
#[allow(dead_code)]
pub fn Move(_vm: &mut Machine) -> bool {
false
}
pub fn Add(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a + b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 + op2);
vm.WalkAddress(4);
true
}
pub fn AddAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] += a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 + op2);
vm.WalkAddress(3);
true
}
pub fn Subtract(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a - b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 - op2);
vm.WalkAddress(4);
true
}
pub fn SubtractAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] -= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 - op2);
vm.WalkAddress(3);
true
}
pub fn Multiply(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a * b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 * op2);
vm.WalkAddress(4);
true
}
pub fn MultiplyAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] *= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 * op2);
vm.WalkAddress(3);
true
}
pub fn Divide(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a / b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 / op2);
vm.WalkAddress(4);
true
}
pub fn DivideAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] /= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 / op2);
vm.WalkAddress(3);
true
}
pub fn Remainder(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a % b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 % op2);
vm.WalkAddress(4);
true
}
pub fn RemainderAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] %= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 % op2);
vm.WalkAddress(3);
true
}
pub fn Neg(vm: &mut Machine) -> bool {
#[allow(dead_code)]
pub fn Neg(_vm: &mut Machine) -> bool {
false
}
pub fn And(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a & b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 & op2);
vm.WalkAddress(4);
true
}
pub fn AndAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] &= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 & op2);
vm.WalkAddress(3);
true
}
pub fn Or(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a | b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 | op2);
vm.WalkAddress(4);
true
}
pub fn OrAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] |= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 | op2);
vm.WalkAddress(3);
true
}
pub fn Xor(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a ^ b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, op1 ^ op2);
vm.WalkAddress(4);
true
}
pub fn XorAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] ^= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
let op2 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 ^ op2);
vm.WalkAddress(3);
true
}
pub fn Not(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] = !a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, !op1);
vm.WalkAddress(3);
true
}
pub fn ShiftLeft(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a << b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 << 1);
vm.WalkAddress(4);
true
}
pub fn ShiftLeftAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] <<= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
vm.SetRegister(reg, op1 << 1);
vm.WalkAddress(2);
true
}
pub fn ShiftRight(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = a >> b;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
vm.SetRegister(reg, op1 >> 1);
vm.WalkAddress(4);
true
}
pub fn ShiftRightAssign(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let pc = vm.GetAddress();
vm.registers[r] >>= a;
vm.program += 3;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(reg);
vm.SetRegister(reg, op1 >> 1);
vm.WalkAddress(2);
true
}
pub fn Equals(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = (a == b) as u8;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, (op1 == op2) as u8);
vm.WalkAddress(4);
true
}
pub fn NotEquals(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = (a != b) as u8;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, (op1 != op2) as u8);
vm.WalkAddress(4);
true
}
pub fn LessThan(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = (a < b) as u8;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, (op1 < op2) as u8);
vm.WalkAddress(4);
true
}
pub fn LessEquals(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = (a <= b) as u8;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, (op1 <= op2) as u8);
vm.WalkAddress(4);
true
}
pub fn GreaterThan(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = (a > b) as u8;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, (op1 > op2) as u8);
vm.WalkAddress(4);
true
}
pub fn GreaterEquals(vm: &mut Machine) -> bool {
let r = vm.memory[vm.program + 1] as usize;
let a = vm.registers[vm.memory[vm.program + 2] as usize];
let b = vm.registers[vm.memory[vm.program + 3] as usize];
let pc = vm.GetAddress();
vm.registers[r] = (a >= b) as u8;
vm.program += 4;
let reg = vm.GetMemory(pc + 1);
let op1 = vm.GetRegister(vm.GetMemory(pc + 2));
let op2 = vm.GetRegister(vm.GetMemory(pc + 3));
vm.SetRegister(reg, (op1 >= op2) as u8);
vm.WalkAddress(4);
true
}
pub fn Halt(vm: &mut Machine) -> bool {
pub fn Halt(_: &mut Machine) -> bool {
false
}