looklook 0.8.0

Descriptive signal synthesiser.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

// Copyright 2026 Gabriel Bjørnager Jensen.
//
// This file is part of LOOKLOOK.
//
// LOOKLOOK is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later ver-
// sion.
//
// LOOKLOOK is distributed in the hope that it will be useful, but WITHOUT ANY WAR-
// RANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
// PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License along
// with LOOKLOOK. If not, see <https://www.gnu.org/licenses/>.

//! The [`An`] enumeration.

/// An address register name.
#[repr(u8)]
#[derive(Copy, Debug)]
#[derive_const(
	Clone,
	Eq,
	Ord,
	PartialEq,
	PartialOrd,
)]
pub enum An {
	/// The `A0` register.
	A0 = 0,

	/// The `A1` register.
	A1 = 1,

	/// The `A2` register.
	A2 = 2,

	/// The `A3` register.
	A3 = 3,

	/// The `A4` register.
	A4 = 4,

	/// The `A5` register.
	A5 = 5,

	/// The frame pointer (`A6`) register.
	Fp = 6,

	/// The stack pointer (`A7`) register.
	Sp = 7,
}

impl An {
	/// The minimum address register index (i.e. `A0`.)
	pub const MIN: Self = Self::A0;

	/// The maximum address register index (i.e. `A7`.)
	pub const MAX: Self = Self::Sp;

	/// Reinterprets a [`u8`] value as an address register.
	///
	/// # Panic
	///
	/// This function may panic if the provided index is greater than `7`.
	#[inline]
	#[must_use]
	pub const fn from_u8(mut index: u8) -> Self {
		if cfg!(overflow_checks) {
			assert!(
				index <= Self::MAX.as_u8(),
				"attempt to construct address register with index greater than `7`",
			);
		}

		// Mask to `3` bits.
		index &= 0b111;

		match index {
			0 => Self::A0,
			1 => Self::A1,
			2 => Self::A2,
			3 => Self::A3,
			4 => Self::A4,
			5 => Self::A5,
			6 => Self::Fp,
			7 => Self::Sp,

			_ => {
				unreachable!();
			}
		}
	}

	/// Reinterprets the register index as a [`u8`] scalar index.
	#[inline(always)]
	#[must_use]
	pub const fn as_u8(self) -> u8 {
		self as u8
	}

	/// Retrieves the data index as a [`usize`] value.
	#[inline]
	#[must_use]
	pub const fn as_usize(self) -> usize {
		self as usize
	}

	/// Retrieves a textual representation of the register.
	#[inline]
	#[must_use]
	pub const fn as_str(self) -> &'static str {
		match self {
			Self::A0 => "A0",
			Self::A1 => "A1",
			Self::A2 => "A2",
			Self::A3 => "A3",
			Self::A4 => "A4",
			Self::A5 => "A5",
			Self::Fp => "FP",
			Self::Sp => "SP",
		}
	}
}