+1

.gitignore

··· 1 1 + /target

+7

Cargo.lock

··· 1 1 + # This file is automatically @generated by Cargo. 2 2 + # It is not intended for manual editing. 3 3 + version = 3 4 4 + 5 5 + [[package]] 6 6 + name = "um" 7 7 + version = "0.1.0"

+8

Cargo.toml

··· 1 1 + [package] 2 2 + name = "um" 3 3 + version = "0.1.0" 4 4 + edition = "2021" 5 5 + 6 6 + [features] 7 7 + default = ["reclaim-memory"] 8 8 + reclaim-memory = []

files/codex.umz

This is a binary file and will not be displayed.

files/sandmark.umz

This is a binary file and will not be displayed.

files/um.um

This is a binary file and will not be displayed.

+401

src/main.rs

··· 1 1 + fn main() { 2 2 + let mut program = Vec::new(); 3 3 + for arg in std::env::args().skip(1) { 4 4 + let p = std::fs::read(arg).unwrap(); 5 5 + program.extend_from_slice(&p); 6 6 + } 7 7 + 8 8 + Um::from_bytes(program) 9 9 + .stdout(std::io::stdout()) 10 10 + .stdin(std::io::stdin()) 11 11 + .run(); 12 12 + } 13 13 + 14 14 + type Platter = u32; 15 15 + type Register = u8; 16 16 + 17 17 + #[derive(Clone, Copy, Debug, PartialEq, Eq)] 18 18 + enum Op { 19 19 + ConditionalMove { 20 20 + a: Register, 21 21 + b: Register, 22 22 + c: Register, 23 23 + }, 24 24 + ArrayIndex { 25 25 + a: Register, 26 26 + b: Register, 27 27 + c: Register, 28 28 + }, 29 29 + ArrayAmendment { 30 30 + a: Register, 31 31 + b: Register, 32 32 + c: Register, 33 33 + }, 34 34 + Addition { 35 35 + a: Register, 36 36 + b: Register, 37 37 + c: Register, 38 38 + }, 39 39 + Multiplication { 40 40 + a: Register, 41 41 + b: Register, 42 42 + c: Register, 43 43 + }, 44 44 + Division { 45 45 + a: Register, 46 46 + b: Register, 47 47 + c: Register, 48 48 + }, 49 49 + NotAnd { 50 50 + a: Register, 51 51 + b: Register, 52 52 + c: Register, 53 53 + }, 54 54 + Halt, 55 55 + Allocation { 56 56 + b: Register, 57 57 + c: Register, 58 58 + }, 59 59 + Abandonment { 60 60 + c: Register, 61 61 + }, 62 62 + Output { 63 63 + c: Register, 64 64 + }, 65 65 + Input { 66 66 + c: Register, 67 67 + }, 68 68 + LoadProgram { 69 69 + b: Register, 70 70 + c: Register, 71 71 + }, 72 72 + Orthography { 73 73 + a: Register, 74 74 + value: u32, 75 75 + }, 76 76 + } 77 77 + 78 78 + impl From<Platter> for Op { 79 79 + fn from(value: Platter) -> Self { 80 80 + let a = ((value >> 6) & 0x07) as Register; 81 81 + let b = ((value >> 3) & 0x07) as Register; 82 82 + let c = ((value >> 0) & 0x07) as Register; 83 83 + 84 84 + match value & 0xf0000000 { 85 85 + 0x00000000 => Self::ConditionalMove { a, b, c }, 86 86 + 0x10000000 => Self::ArrayIndex { a, b, c }, 87 87 + 0x20000000 => Self::ArrayAmendment { a, b, c }, 88 88 + 0x30000000 => Self::Addition { a, b, c }, 89 89 + 0x40000000 => Self::Multiplication { a, b, c }, 90 90 + 0x50000000 => Self::Division { a, b, c }, 91 91 + 0x60000000 => Self::NotAnd { a, b, c }, 92 92 + 0x70000000 => Self::Halt, 93 93 + 0x80000000 => Self::Allocation { b, c }, 94 94 + 0x90000000 => Self::Abandonment { c }, 95 95 + 0xa0000000 => Self::Output { c }, 96 96 + 0xb0000000 => Self::Input { c }, 97 97 + 0xc0000000 => Self::LoadProgram { b, c }, 98 98 + 0xd0000000 => { 99 99 + let a = ((value >> 25) & 0x07) as Register; 100 100 + let value = value & 0x01ffffff; 101 101 + Self::Orthography { a, value } 102 102 + } 103 103 + _ => Self::Halt, 104 104 + } 105 105 + } 106 106 + } 107 107 + 108 108 + fn decode_ops(ops: &[Platter]) -> Vec<Op> { 109 109 + ops.iter().map(|encoded| Op::from(*encoded)).collect() 110 110 + } 111 111 + 112 112 + #[derive(Default)] 113 113 + pub struct Um { 114 114 + program_counter: Platter, 115 115 + registers: [Platter; 8], 116 116 + memory: Vec<Vec<Platter>>, 117 117 + #[cfg(feature = "reclaim-memory")] 118 118 + free_blocks: Vec<Platter>, 119 119 + ops: Vec<Op>, 120 120 + stdin: Option<Box<dyn std::io::Read>>, 121 121 + stdout: Option<Box<dyn std::io::Write>>, 122 122 + } 123 123 + 124 124 + impl Um { 125 125 + /// Construct a new Universal Machine with the specified program. 126 126 + pub fn new(program: Vec<Platter>) -> Self { 127 127 + let ops = decode_ops(&program); 128 128 + Self { 129 129 + memory: vec![program], 130 130 + ops, 131 131 + ..Default::default() 132 132 + } 133 133 + } 134 134 + 135 135 + /// Construct a new Universal Machine from a program represented in bytes. 136 136 + pub fn from_bytes(program: impl AsRef<[u8]>) -> Self { 137 137 + let bytes = program.as_ref(); 138 138 + let mut program = Vec::with_capacity(bytes.len().div_ceil(size_of::<Platter>())); 139 139 + for word in bytes.chunks(size_of::<Platter>()) { 140 140 + let value = Platter::from_be_bytes(match word { 141 141 + [a, b, c, d] => [*a, *b, *c, *d], 142 142 + [a, b, c] => [*a, *b, *c, 0], 143 143 + [a, b] => [*a, *b, 0, 0], 144 144 + [a] => [*a, 0, 0, 0], 145 145 + _ => unreachable!(), 146 146 + }); 147 147 + program.push(value); 148 148 + } 149 149 + 150 150 + Self::new(program) 151 151 + } 152 152 + 153 153 + /// Sets the output for the univeral machine. 154 154 + pub fn stdout(mut self, stdout: impl std::io::Write + 'static) -> Self { 155 155 + self.stdout.replace(Box::new(stdout)); 156 156 + self 157 157 + } 158 158 + 159 159 + /// Sets the input for the universal machine. 160 160 + pub fn stdin(mut self, stdin: impl std::io::Read + 'static) -> Self { 161 161 + self.stdin.replace(Box::new(stdin)); 162 162 + self 163 163 + } 164 164 + 165 165 + /// Begins the spin-cycle of the universal machine. 166 166 + pub fn run(mut self) { 167 167 + loop { 168 168 + match self.ops[self.program_counter as usize] { 169 169 + // Operator #0. Conditional Move. 170 170 + // 171 171 + // The register A receives the value in register B, 172 172 + // unless the register C contains 0. 173 173 + Op::ConditionalMove { a, b, c } => { 174 174 + if self.load_register(c) != 0 { 175 175 + self.save_register(a, self.load_register(b)); 176 176 + } 177 177 + } 178 178 + 179 179 + // Operator #1: Array Index. 180 180 + // 181 181 + // The register A receives the value stored at offset 182 182 + // in register C in the array identified by B. 183 183 + Op::ArrayIndex { a, b, c } => { 184 184 + let block = self.load_register(b); 185 185 + let offset = self.load_register(c); 186 186 + self.save_register(a, self.load_memory(block, offset)); 187 187 + } 188 188 + 189 189 + // Operator #2. Array Amendment. 190 190 + // 191 191 + // The array identified by A is amended at the offset 192 192 + // in register B to store the value in register C. 193 193 + Op::ArrayAmendment { a, b, c } => { 194 194 + let block = self.load_register(a); 195 195 + let offset = self.load_register(b); 196 196 + let value = self.load_register(c); 197 197 + self.store_memory(block, offset, value); 198 198 + } 199 199 + 200 200 + // Operator #3. Addition. 201 201 + // 202 202 + // The register A receives the value in register B plus 203 203 + // the value in register C, modulo 2^32. 204 204 + Op::Addition { a, b, c } => { 205 205 + self.save_register( 206 206 + a, 207 207 + self.load_register(b).wrapping_add(self.load_register(c)), 208 208 + ); 209 209 + } 210 210 + 211 211 + // Operator #4. Multiplication. 212 212 + // 213 213 + // The register A receives the value in register B times 214 214 + // the value in register C, modulo 2^32. 215 215 + Op::Multiplication { a, b, c } => { 216 216 + self.save_register( 217 217 + a, 218 218 + self.load_register(b).wrapping_mul(self.load_register(c)), 219 219 + ); 220 220 + } 221 221 + 222 222 + // Operator #5. Division. 223 223 + // 224 224 + // The register A receives the value in register B 225 225 + // divided by the value in register C, if any, where 226 226 + // each quantity is treated as an unsigned 32 bit number. 227 227 + Op::Division { a, b, c } => { 228 228 + self.save_register( 229 229 + a, 230 230 + self.load_register(b).wrapping_div(self.load_register(c)), 231 231 + ); 232 232 + } 233 233 + 234 234 + // Operator #6. Not-And. 235 235 + // 236 236 + // Each bit in the register A receives the 1 bit if 237 237 + // either register B or register C has a 0 bit in that 238 238 + // position. Otherwise the bit in register A receives 239 239 + // the 0 bit. 240 240 + Op::NotAnd { a, b, c } => { 241 241 + self.save_register(a, !(self.load_register(b) & self.load_register(c))); 242 242 + } 243 243 + 244 244 + // Operator #7. Halt. 245 245 + // 246 246 + // The universal machine stops computation. 247 247 + Op::Halt => break, 248 248 + 249 249 + // Operator #8. Allocation. 250 250 + // 251 251 + // A new array is created with a capacity of platters 252 252 + // commensurate to the value in the register C. This 253 253 + // new array is initialized entirely with platters 254 254 + // holding the value 0. A bit pattern not consisting of 255 255 + // exclusively the 0 bit, and that identifies no other 256 256 + // active allocated array, is placed in the B register. 257 257 + Op::Allocation { b, c } => { 258 258 + let length = self.load_register(c); 259 259 + let index = self.allocate_memory(length); 260 260 + self.save_register(b, index); 261 261 + } 262 262 + 263 263 + // Operator #9. Abandonment. 264 264 + // 265 265 + // The array identified by the register C is abandoned. 266 266 + // Future allocations may then reuse that identifier. 267 267 + Op::Abandonment { c } => { 268 268 + let block = self.load_register(c); 269 269 + self.free_memory(block); 270 270 + } 271 271 + 272 272 + // Operator #10. Output. 273 273 + // 274 274 + // The value in the register C is displayed on the console 275 275 + // immediately. Only values between and including 0 and 255 276 276 + // are allowed. 277 277 + Op::Output { c } => { 278 278 + let value = self.load_register(c); 279 279 + if let Some(stdout) = self.stdout.as_mut() { 280 280 + let buffer = [(value & 0xff) as u8]; 281 281 + stdout.write_all(&buffer).unwrap(); 282 282 + } 283 283 + } 284 284 + 285 285 + // Operator #11. Input. 286 286 + // 287 287 + // The universal machine waits for input on the console. 288 288 + // When input arrives, the register C is loaded with the 289 289 + // input, which must be between and including 0 and 255. 290 290 + // If the end of input has been signaled, then the 291 291 + // register C is endowed with a uniform value pattern 292 292 + // where every place is pregnant with the 1 bit. 293 293 + Op::Input { c } => { 294 294 + if let Some(stdin) = self.stdin.as_mut() { 295 295 + let mut buffer = vec![0]; 296 296 + match stdin.read_exact(&mut buffer) { 297 297 + Ok(()) => self.save_register(c, buffer[0] as u32), 298 298 + Err(_) => self.save_register(c, 0xff), 299 299 + } 300 300 + } else { 301 301 + self.save_register(c, 0xff); 302 302 + } 303 303 + } 304 304 + 305 305 + // Operator #12. Load Program. 306 306 + // 307 307 + // The array identified by the B register is duplicated 308 308 + // and the duplicate shall replace the '0' array, 309 309 + // regardless of size. The execution finger is placed 310 310 + // to indicate the platter of this array that is 311 311 + // described by the offset given in C, where the value 312 312 + // 0 denotes the first platter, 1 the second, et 313 313 + // cetera. 314 314 + // 315 315 + // The '0' array shall be the most sublime choice for 316 316 + // loading, and shall be handled with the utmost 317 317 + // velocity. 318 318 + Op::LoadProgram { b, c } => { 319 319 + let block = self.load_register(b); 320 320 + 321 321 + // Source array is always copied to array[0], but there 322 322 + // is no point copying array[0] to array[0]. 323 323 + if block != 0 { 324 324 + let duplicated = self.duplicate_memory(block); 325 325 + let ops = decode_ops(&duplicated); 326 326 + self.ops = ops; 327 327 + } 328 328 + 329 329 + self.program_counter = self.load_register(c); 330 330 + continue; 331 331 + } 332 332 + 333 333 + // Operator #13. Orthography. 334 334 + // 335 335 + // The value indicated is loaded into the register A 336 336 + // forthwith. 337 337 + Op::Orthography { a, value } => { 338 338 + self.save_register(a, value); 339 339 + } 340 340 + } 341 341 + 342 342 + self.program_counter += 1; 343 343 + } 344 344 + } 345 345 + 346 346 + /// Loads the value from the specified register. 347 347 + fn load_register(&self, index: Register) -> Platter { 348 348 + debug_assert!(index < 8, "register index out of bounds"); 349 349 + self.registers[index as usize] 350 350 + } 351 351 + 352 352 + /// Saves a value to the specified register. 353 353 + fn save_register(&mut self, index: Register, value: Platter) { 354 354 + debug_assert!(index < 8, "register index out of bounds"); 355 355 + self.registers[index as usize] = value; 356 356 + } 357 357 + 358 358 + fn load_memory(&self, block: Platter, offset: Platter) -> Platter { 359 359 + debug_assert!((block as usize) < self.memory.len()); 360 360 + debug_assert!((offset as usize) < self.memory[block as usize].len()); 361 361 + self.memory[block as usize][offset as usize] 362 362 + } 363 363 + 364 364 + fn store_memory(&mut self, block: Platter, offset: Platter, value: Platter) { 365 365 + debug_assert!((block as usize) < self.memory.len()); 366 366 + debug_assert!((offset as usize) < self.memory[block as usize].len()); 367 367 + self.memory[block as usize][offset as usize] = value; 368 368 + } 369 369 + 370 370 + fn duplicate_memory(&mut self, block: Platter) -> &[Platter] { 371 371 + debug_assert!((block as usize) < self.memory.len()); 372 372 + self.memory[0] = self.memory[block as usize].clone(); 373 373 + &self.memory[0] 374 374 + } 375 375 + 376 376 + #[cfg(not(feature = "reclaim-memory"))] 377 377 + fn allocate_memory(&mut self, length: Platter) -> Platter { 378 378 + self.memory.push(vec![0; length as usize]); 379 379 + (self.memory.len() - 1) as Platter 380 380 + } 381 381 + 382 382 + #[cfg(feature = "reclaim-memory")] 383 383 + fn allocate_memory(&mut self, length: Platter) -> Platter { 384 384 + if let Some(index) = self.free_blocks.pop() { 385 385 + self.memory[index as usize] = vec![0; length as usize]; 386 386 + index as Platter 387 387 + } else { 388 388 + self.memory.push(vec![0; length as usize]); 389 389 + (self.memory.len() - 1) as Platter 390 390 + } 391 391 + } 392 392 + 393 393 + fn free_memory(&mut self, block: Platter) { 394 394 + debug_assert!((block as usize) < self.memory.len()); 395 395 + #[cfg(feature = "reclaim-memory")] 396 396 + { 397 397 + self.free_blocks.push(block); 398 398 + self.memory[block as usize] = vec![]; 399 399 + } 400 400 + } 401 401 + }