Something went wrong. Try again.
Implementation of the UM-32 "Universal Machine" as described by the [Cult of the Bound Variable](http://boundvariable.org/)
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192// Copyright (C) 2025 Thom Hayward.//// This program is free software: you can redistribute it and/or modify it under// the terms of the GNU General Public License as published by the Free Software// Foundation, version 3.//// This program is distributed in the hope that it will be useful, but WITHOUT// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more// details.//// You should have received a copy of the GNU General Public License along with// this program. If not, see <https://www.gnu.org/licenses/>.//
use crate::reg::Register;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]pub enum Operation { /// Operator #0. Conditional Move. /// /// The register A receives the value in register B, /// unless the register C contains 0. ConditionalMove { a: Register, b: Register, c: Register, }, /// Operator #1: Array Index. /// /// The register A receives the value stored at offset /// in register C in the array identified by B. ArrayIndex { a: Register, b: Register, c: Register, }, /// Operator #2. Array Amendment. /// /// The array identified by A is amended at the offset /// in register B to store the value in register C. ArrayAmendment { a: Register, b: Register, c: Register, }, /// Operator #3. Addition. /// /// The register A receives the value in register B plus /// the value in register C, modulo 2^32. Addition { a: Register, b: Register, c: Register, }, /// Operator #4. Multiplication. /// /// The register A receives the value in register B times /// the value in register C, modulo 2^32. Multiplication { a: Register, b: Register, c: Register, }, /// Operator #5. Division. /// /// The register A receives the value in register B /// divided by the value in register C, if any, where /// each quantity is treated as an unsigned 32 bit number. Division { a: Register, b: Register, c: Register, }, /// Operator #6. Not-And. /// /// Each bit in the register A receives the 1 bit if /// either register B or register C has a 0 bit in that /// position. Otherwise the bit in register A receives /// the 0 bit. NotAnd { a: Register, b: Register, c: Register, }, /// Operator #7. Halt. /// /// The universal machine stops computation. Halt, /// Operator #8. Allocation. /// /// A new array is created with a capacity of platters /// commensurate to the value in the register C. This /// new array is initialized entirely with platters /// holding the value 0. A bit pattern not consisting of /// exclusively the 0 bit, and that identifies no other /// active allocated array, is placed in the B register. Allocation { b: Register, c: Register, }, /// Operator #9. Abandonment. /// /// The array identified by the register C is abandoned. /// Future allocations may then reuse that identifier. Abandonment { c: Register, }, /// Operator #10. Output. /// /// The value in the register C is displayed on the console /// immediately. Only values between and including 0 and 255 /// are allowed. Output { c: Register, }, /// Operator #11. Input. /// /// The universal machine waits for input on the console. /// When input arrives, the register C is loaded with the /// input, which must be between and including 0 and 255. /// If the end of input has been signaled, then the /// register C is endowed with a uniform value pattern /// where every place is pregnant with the 1 bit. Input { c: Register, }, /// Operator #12. Load Program. /// /// The array identified by the B register is duplicated /// and the duplicate shall replace the '0' array, /// regardless of size. The execution finger is placed /// to indicate the platter of this array that is /// described by the offset given in C, where the value /// 0 denotes the first platter, 1 the second, et /// cetera. /// /// The '0' array shall be the most sublime choice for /// loading, and shall be handled with the utmost /// velocity. LoadProgram { b: Register, c: Register, }, /// Operator #13. Orthography. /// /// The value indicated is loaded into the register A /// forthwith. Orthography { a: Register, value: u32, }, IllegalInstruction,}
impl From<u32> for Operation { fn from(value: u32) -> Self { let a = Register::from_u8(((value >> 6) & 0x07) as u8); let b = Register::from_u8(((value >> 3) & 0x07) as u8); let c = Register::from_u8((value & 0x07) as u8); match value & 0xf000_0000 { 0x0000_0000 => Self::ConditionalMove { a, b, c }, 0x1000_0000 => Self::ArrayIndex { a, b, c }, 0x2000_0000 => Self::ArrayAmendment { a, b, c }, 0x3000_0000 => Self::Addition { a, b, c }, 0x4000_0000 => Self::Multiplication { a, b, c }, 0x5000_0000 => Self::Division { a, b, c }, 0x6000_0000 => Self::NotAnd { a, b, c }, 0x7000_0000 => Self::Halt, 0x8000_0000 => Self::Allocation { b, c }, 0x9000_0000 => Self::Abandonment { c }, 0xa000_0000 => Self::Output { c }, 0xb000_0000 => Self::Input { c }, 0xc000_0000 => Self::LoadProgram { b, c }, 0xd000_0000 => { let a = Register::from_u8(((value >> 25) & 0x07) as u8); let value = value & 0x01ff_ffff; Self::Orthography { a, value } } _ => Self::IllegalInstruction, } }}
/// Decode a Universal Machine program into a [`Vec`] of [`Operation`]s.#[must_use]pub fn decode(ops: &[u32]) -> Vec<Operation> { ops.iter() .map(|&encoded| Operation::from(encoded)) .collect()}