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

//! Intermediate representation for integral types.

/// Which integral type are we dealing with?
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum IntKind {
    /// A `bool`.
    Bool,

    /// A `signed char`.
    SChar,

    /// An `unsigned char`.
    UChar,

    /// A platform-dependent `char` type, with the signedness support.
    Char {
        /// Whether the char is signed for the target platform.
        is_signed: bool,
    },

    /// A `short`.
    Short,

    /// An `unsigned short`.
    UShort,

    /// An `int`.
    Int,

    /// An `unsigned int`.
    UInt,

    /// A `long`.
    Long,

    /// An `unsigned long`.
    ULong,

    /// A `long long`.
    LongLong,

    /// An `unsigned long long`.
    ULongLong,

    /// A 8-bit signed integer.
    I8,

    /// A 8-bit unsigned integer.
    U8,

    /// A 16-bit signed integer.
    I16,

    /// Either a `char16_t` or a `wchar_t`.
    U16,

    /// A 32-bit signed integer.
    I32,

    /// A 32-bit unsigned integer.
    U32,

    /// A 64-bit signed integer.
    I64,

    /// A 64-bit unsigned integer.
    U64,

    /// An `int128_t`
    I128,

    /// A `uint128_t`.
    U128,

    /// A custom integer type, used to allow custom macro types depending on
    /// range.
    Custom {
        /// The name of the type, which would be used without modification.
        name: &'static str,
        /// Whether the type is signed or not.
        is_signed: bool,
    },
}

impl IntKind {
    /// Is this integral type signed?
    pub fn is_signed(&self) -> bool {
        use self::IntKind::*;
        match *self {
            Bool | UChar | UShort | UInt | ULong | ULongLong | U8 | U16 |
            U32 | U64 | U128 => false,

            SChar | Short | Int | Long | LongLong | I8 | I16 | I32 | I64 |
            I128 => true,

            Char {
                is_signed,
            } => is_signed,

            Custom {
                is_signed, ..
            } => is_signed,
        }
    }

    /// If this type has a known size, return it (in bytes). This is to
    /// alleviate libclang sometimes not giving us a layout (like in the case
    /// when an enum is defined inside a class with template parameters).
    pub fn known_size(&self) -> Option<usize> {
        use self::IntKind::*;
        Some(match *self {
            Bool |
            UChar |
            SChar |
            U8 |
            I8 |
            Char {
                ..
            } => 1,
            U16 | I16 => 2,
            U32 | I32 => 4,
            U64 | I64 => 8,
            I128 | U128 => 16,
            _ => return None,
        })
    }

    /// Whether this type's signedness matches the value.
    pub fn signedness_matches(&self, val: i64) -> bool {
        val >= 0 || self.is_signed()
    }
}