rain-lang 0.0.1

An implementation of an RVSDG in Rust with a concept of lifetimes
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

/*!
Binary constants
*/
use super::logical::LogicalOp;
use num::{BigInt, BigUint};
use std::fmt::{Debug, Display, Formatter, self};

/// The maximum number of bits a small binary constant can hold
pub const MAX_SMALL_BITS: u8 = 128;

/// A single bit
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
#[repr(transparent)]
pub struct Bit(pub bool);

/// A binary bitwise logical operation
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct Bitwise {
    /// The operation to carry out
    op: LogicalOp,
    /// The number of bits to carry it out on
    bits: u16
}

/// A small amount of bits
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct SmallBits(u8);

/// Display mode for a binary constant
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum BinaryDisplay {
    /// Binary display, (bits)'b(value) for binary, 0b(value) for integer
    Bin,
    /// Octal display, (bits)'o(value) for binary, 0o(value) for integer
    Oct,
    /// Decimal display (bits)'d(value) for binary, 0d(value) for integer
    Dec,
    /// Hexadecimal display, (bits)'h(value) for binary, 0x(value) for integer
    Hex
}

/// A small binary constant
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct Binary {
    bits: SmallBits,
    display: BinaryDisplay,
    value: u128
}

/// A big natural number
#[derive(Clone, Eq, PartialEq, Hash)]
pub struct Natural(pub BigUint, pub BinaryDisplay);

impl Debug for Natural {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
        <Self as Display>::fmt(self, fmt)
    }
}

impl Display for Natural {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
        use BinaryDisplay::*;
        match self.1 {
            Bin => write!(fmt, "{:#b}", self.0),
            Oct => write!(fmt, "{:#o}", self.0),
            Dec => write!(fmt, "{}", self.0),
            Hex => write!(fmt, "{:#x}", self.0)
        }
    }
}

/// A big integer
#[derive(Clone, Eq, PartialEq, Hash)]
pub struct Integer(pub BigInt, pub BinaryDisplay);


impl Debug for Integer {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
        <Self as Display>::fmt(self, fmt)
    }
}

impl Display for Integer {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
        use BinaryDisplay::*;
        match self.1 {
            Bin => write!(fmt, "{:#b}", self.0),
            Oct => write!(fmt, "{:#o}", self.0),
            Dec => write!(fmt, "{}", self.0),
            Hex => write!(fmt, "{:#x}", self.0)
        }
    }
}