csx64 0.1.2

An Intel-style x64 assembler and executor.
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

use std::fmt;

/// Returns the quotient and remainder of `a` divided by `b`.
pub(crate) fn quotient_and_remainder<T>(a: T, b: T) -> (T, T) where T: std::ops::Div<Output = T> + std::ops::Rem<Output = T> + Copy {
    (a / b, a % b)
}

pub(crate) struct Punctuated<'a, T> { 
    vals: &'a [T],
    sep: &'static str,
    sep_special: &'static str,
}
impl<'a, T> Punctuated<'a, T> {
    pub(crate) fn or(vals: &'a [T]) -> Self {
        Self { vals, sep: ", ", sep_special: "or " }
    }
    #[cfg(test)]
    pub(crate) fn and(vals: &'a [T]) -> Self {
        Self { vals, sep: ", ", sep_special: "and " }
    }
    #[cfg(test)]
    pub(crate) fn join(vals: &'a [T], sep: &'static str) -> Self {
        Self { vals, sep, sep_special: "" }
    }
}
impl<'a, T: fmt::Display> fmt::Display for Punctuated<'a, T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.vals {
            [] => Ok(()),
            [x] => write!(f, "{}", x),
            [x, y] => {
                if self.sep_special.is_empty() { write!(f, "{}{}{}", x, self.sep, y) }
                else { write!(f, "{} {}{}", x, self.sep_special, y) }
            }
            [prev @ .., last] => {
                for x in prev {
                    write!(f, "{}{}", x, self.sep)?;
                }
                write!(f, "{}{}", self.sep_special, last)
            }
        }
    }
}
impl<'a, T: fmt::Debug> fmt::Debug for Punctuated<'a, T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.vals {
            [] => Ok(()),
            [x] => write!(f, "{:?}", x),
            [x, y] => {
                if self.sep_special.is_empty() { write!(f, "{:?}{}{:?}", x, self.sep, y) }
                else { write!(f, "{:?} {}{:?}", x, self.sep_special, y) }
            }
            [prev @ .., last] => {
                for x in prev {
                    write!(f, "{:?}{}", x, self.sep)?;
                }
                write!(f, "{}{:?}", self.sep_special, last)
            }
        }
    }
}
#[test]
fn test_comma_chain() {
    assert_eq!(format!("{}", Punctuated::or(&[] as &[i32])), "");
    assert_eq!(format!("{}", Punctuated::or(&[8])), "8");
    assert_eq!(format!("{}", Punctuated::or(&[8, 7])), "8 or 7");
    assert_eq!(format!("{}", Punctuated::or(&[8, 7, 5])), "8, 7, or 5");
    assert_eq!(format!("{}", Punctuated::or(&[8, 7, 5, 2, 1])), "8, 7, 5, 2, or 1");

    assert_eq!(format!("{}", Punctuated::and(&[] as &[i32])), "");
    assert_eq!(format!("{}", Punctuated::and(&[8])), "8");
    assert_eq!(format!("{}", Punctuated::and(&[8, 7])), "8 and 7");
    assert_eq!(format!("{}", Punctuated::and(&[8, 7, 5])), "8, 7, and 5");
    assert_eq!(format!("{}", Punctuated::and(&[8, 7, 5, 2, 1])), "8, 7, 5, 2, and 1");

    assert_eq!(format!("{}", Punctuated::join(&[] as &[i32], ", ")), "");
    assert_eq!(format!("{}", Punctuated::join(&[8], ", ")), "8");
    assert_eq!(format!("{}", Punctuated::join(&[8, 7], ", ")), "8, 7");
    assert_eq!(format!("{}", Punctuated::join(&[8, 7, 5], ", ")), "8, 7, 5");
    assert_eq!(format!("{}", Punctuated::join(&[8, 7, 5, 2, 1], ", ")), "8, 7, 5, 2, 1");

    assert_eq!(format!("{}", Punctuated::join(&[] as &[i32], ",")), "");
    assert_eq!(format!("{}", Punctuated::join(&[8], ",")), "8");
    assert_eq!(format!("{}", Punctuated::join(&[8, 7], ",")), "8,7");
    assert_eq!(format!("{}", Punctuated::join(&[8, 7, 5], ",")), "8,7,5");
    assert_eq!(format!("{}", Punctuated::join(&[8, 7, 5, 2, 1], ",")), "8,7,5,2,1");

    // -------------------------------------------------------------------

    assert_eq!(format!("{:?}", Punctuated::or(&[] as &[i32])), "");
    assert_eq!(format!("{:?}", Punctuated::or(&[8])), "8");
    assert_eq!(format!("{:?}", Punctuated::or(&[8, 7])), "8 or 7");
    assert_eq!(format!("{:?}", Punctuated::or(&[8, 7, 5])), "8, 7, or 5");
    assert_eq!(format!("{:?}", Punctuated::or(&[8, 7, 5, 2, 1])), "8, 7, 5, 2, or 1");

    assert_eq!(format!("{:?}", Punctuated::and(&[] as &[i32])), "");
    assert_eq!(format!("{:?}", Punctuated::and(&[8])), "8");
    assert_eq!(format!("{:?}", Punctuated::and(&[8, 7])), "8 and 7");
    assert_eq!(format!("{:?}", Punctuated::and(&[8, 7, 5])), "8, 7, and 5");
    assert_eq!(format!("{:?}", Punctuated::and(&[8, 7, 5, 2, 1])), "8, 7, 5, 2, and 1");

    assert_eq!(format!("{:?}", Punctuated::join(&[] as &[i32], ", ")), "");
    assert_eq!(format!("{:?}", Punctuated::join(&[8], ", ")), "8");
    assert_eq!(format!("{:?}", Punctuated::join(&[8, 7], ", ")), "8, 7");
    assert_eq!(format!("{:?}", Punctuated::join(&[8, 7, 5], ", ")), "8, 7, 5");
    assert_eq!(format!("{:?}", Punctuated::join(&[8, 7, 5, 2, 1], ", ")), "8, 7, 5, 2, 1");

    assert_eq!(format!("{:?}", Punctuated::join(&[] as &[i32], ",")), "");
    assert_eq!(format!("{:?}", Punctuated::join(&[8], ",")), "8");
    assert_eq!(format!("{:?}", Punctuated::join(&[8, 7], ",")), "8,7");
    assert_eq!(format!("{:?}", Punctuated::join(&[8, 7, 5], ",")), "8,7,5");
    assert_eq!(format!("{:?}", Punctuated::join(&[8, 7, 5, 2, 1], ",")), "8,7,5,2,1");
}