btor2rs 0.1.0

Safe-Rust Btor2 parser
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

//! Sort and node identifiers.
use std::{
    fmt::Display,
    num::{NonZeroI32, NonZeroU32},
};

use crate::line::LineError;

/// Sort identifier.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Sid(NonZeroU32);

impl Sid {
    /// Get the actual identifier number.
    pub fn get(&self) -> u32 {
        self.0.get()
    }

    pub(crate) fn try_from_str(value: &str) -> Result<Self, LineError> {
        // ensure it is positive and fits into i32 for compatibility with nids
        if let Ok(sid) = value.parse::<NonZeroU32>() {
            if sid.get() <= i32::MAX as u32 {
                return Ok(Sid(sid));
            }
        }
        Err(LineError::InvalidSid(String::from(value)))
    }
}

/// Node identifier.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Nid(NonZeroU32);

impl Nid {
    /// Get the actual identifier number.
    pub fn get(&self) -> NonZeroU32 {
        self.0
    }

    pub(crate) fn try_from_str(value: &str) -> Result<Self, LineError> {
        // ensure it is positive and fits into i32 for compatibility with rnids
        if let Ok(nid) = value.parse::<NonZeroU32>() {
            if nid.get() <= i32::MAX as u32 {
                return Ok(Nid(nid));
            }
        }
        Err(LineError::InvalidNid(String::from(value)))
    }
}

/// Right-side node identifier with optional bitwise negation.
///
/// Right-side nodes [can be immediately bit-inverted by using a minus sign](
/// https://github.com/Boolector/btor2tools/issues/15) before the node
/// identifier. This structure stores both the node identifier and the
/// bit-inversion flag.
#[derive(Debug, Clone, Copy, Hash)]
pub struct Rnid(NonZeroI32);

impl Rnid {
    /// Return the node identifier.
    pub fn nid(&self) -> Nid {
        // convert to positive
        // we cannot do checked_abs directly on NonZeroI32 in stable yet, so conversion
        // to primitive i32 is necessary
        // we know that checked_abs will not throw, as we already tested it in try_from_str
        let positive = self.0.get().checked_abs().unwrap();
        // we know that creating nonzero will not throw
        Nid(NonZeroU32::new(positive as u32).unwrap())
    }

    /// Return whether the node should be bit-inverted before applying it as an argument.
    ///
    /// Note that despite the minus sign being used, the bit-inversion corresponds to
    /// `std::ops::Not`, i.e. `!a`.
    pub fn is_not(&self) -> bool {
        self.0.get() < 0
    }

    pub(crate) fn try_from_str(value: &str) -> Result<Self, LineError> {
        if let Ok(rnid) = value.parse::<NonZeroI32>() {
            // ensure that the absolute value exists
            // this means i32::MIN cannot be stored
            if rnid.checked_abs().is_some() {
                return Ok(Rnid(rnid));
            }
        }
        Err(LineError::InvalidRnid(String::from(value)))
    }
}

impl Display for Sid {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl Display for Nid {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}