ull 0.2.0

Provides core primitives for the ull emulation project.
Documentation 
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
126
127
128
129
130
131
132

//! Marker trait for values that can act as memory addresses.
//!
//! Implementers expose a uniform way to index (`as_usize`) plus wrapping addition
//! and subtraction so buses can walk memory without caring about the underlying
//! width (zero-page `Byte`, full `Word`, or even plain integers).

use core::ops::{Add, AddAssign, Sub, SubAssign};

use crate::{Byte, Nibble, Word};

pub trait Address:
    Copy + Add<usize, Output = Self> + Sub<usize, Output = Self> + AddAssign<usize> + SubAssign<usize>
{
    /// Returns the address as a host `usize` for indexing.
    fn as_usize(self) -> usize;

    /// Returns the address truncated to 16 bits.
    #[inline]
    fn as_u16(self) -> u16 {
        self.as_usize() as u16
    }

    /// Returns the address truncated to 8 bits.
    #[inline]
    fn as_u8(self) -> u8 {
        self.as_usize() as u8
    }
}

impl Address for Byte {
    #[inline]
    fn as_usize(self) -> usize {
        self.0 as usize
    }

    #[inline]
    fn as_u16(self) -> u16 {
        self.0 as u16
    }

    #[inline]
    fn as_u8(self) -> u8 {
        self.0
    }
}

impl AddAssign<usize> for Byte {
    fn add_assign(&mut self, rhs: usize) {
        self.0 = self.0.wrapping_add(rhs as u8);
    }
}

impl SubAssign<usize> for Byte {
    fn sub_assign(&mut self, rhs: usize) {
        self.0 = self.0.wrapping_sub(rhs as u8);
    }
}

impl Address for Nibble {
    #[inline]
    fn as_usize(self) -> usize {
        usize::from(self.0)
    }

    #[inline]
    fn as_u16(self) -> u16 {
        u16::from(self.0)
    }

    #[inline]
    fn as_u8(self) -> u8 {
        self.0
    }
}

impl AddAssign<usize> for Nibble {
    fn add_assign(&mut self, rhs: usize) {
        *self = *self + rhs;
    }
}

impl SubAssign<usize> for Nibble {
    fn sub_assign(&mut self, rhs: usize) {
        *self = *self - rhs;
    }
}

impl Address for Word {
    #[inline]
    fn as_usize(self) -> usize {
        self.0 as usize
    }

    #[inline]
    fn as_u16(self) -> u16 {
        self.0
    }

    #[inline]
    fn as_u8(self) -> u8 {
        (self.0 & 0x00FF) as u8
    }
}

impl AddAssign<usize> for Word {
    fn add_assign(&mut self, rhs: usize) {
        self.0 = self.0.wrapping_add(rhs as u16);
    }
}

impl SubAssign<usize> for Word {
    fn sub_assign(&mut self, rhs: usize) {
        self.0 = self.0.wrapping_sub(rhs as u16);
    }
}

impl Address for usize {
    #[inline]
    fn as_usize(self) -> usize {
        self
    }

    #[inline]
    fn as_u16(self) -> u16 {
        self as u16
    }

    #[inline]
    fn as_u8(self) -> u8 {
        self as u8
    }
}