591 lines
24 KiB
Rust
591 lines
24 KiB
Rust
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use std::cmp::Ordering;
|
|
use syntax::attr::IntType;
|
|
use syntax::ast::{IntTy, UintTy};
|
|
|
|
use super::isize::*;
|
|
use super::usize::*;
|
|
use super::err::*;
|
|
|
|
#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, Hash, Eq, PartialEq)]
|
|
pub enum ConstInt {
|
|
I8(i8),
|
|
I16(i16),
|
|
I32(i32),
|
|
I64(i64),
|
|
I128(i128),
|
|
Isize(ConstIsize),
|
|
U8(u8),
|
|
U16(u16),
|
|
U32(u32),
|
|
U64(u64),
|
|
U128(u128),
|
|
Usize(ConstUsize),
|
|
}
|
|
pub use self::ConstInt::*;
|
|
|
|
|
|
macro_rules! bounds {
|
|
($ct: ty, $($t:ident $min:ident $max:ident)*) => {
|
|
$(
|
|
pub const $min: $ct = $t::min_value() as $ct;
|
|
pub const $max: $ct = $t::max_value() as $ct;
|
|
)*
|
|
};
|
|
($ct: ty: $min_val: expr, $($t:ident $min:ident $max:ident)*) => {
|
|
$(
|
|
pub const $min: $ct = $min_val;
|
|
pub const $max: $ct = $t::max_value() as $ct;
|
|
)*
|
|
}
|
|
}
|
|
|
|
mod ubounds {
|
|
#![allow(dead_code)]
|
|
bounds!{u128: 0,
|
|
i8 I8MIN I8MAX i16 I16MIN I16MAX i32 I32MIN I32MAX i64 I64MIN I64MAX i128 I128MIN I128MAX
|
|
u8 U8MIN U8MAX u16 U16MIN U16MAX u32 U32MIN U32MAX u64 U64MIN U64MAX u128 U128MIN U128MAX
|
|
// do not add constants for isize/usize, because these are guaranteed to be wrong for
|
|
// arbitrary host/target combinations
|
|
}
|
|
}
|
|
|
|
mod ibounds {
|
|
#![allow(dead_code)]
|
|
bounds!(i128, u64 U64MIN U64MAX);
|
|
|
|
pub const U128MIN: i128 = 0;
|
|
pub const U128MAX: i128 = i128::max_value();
|
|
|
|
bounds!{i128,
|
|
i8 I8MIN I8MAX i16 I16MIN I16MAX i32 I32MIN I32MAX i64 I64MIN I64MAX i128 I128MIN I128MAX
|
|
u8 U8MIN U8MAX u16 U16MIN U16MAX u32 U32MIN U32MAX
|
|
// do not add constants for isize/usize, because these are guaranteed to be wrong for
|
|
// arbitrary host/target combinations
|
|
}
|
|
}
|
|
|
|
impl ConstInt {
|
|
/// Creates a new unsigned ConstInt with matching type while also checking that overflow does
|
|
/// not happen.
|
|
pub fn new_unsigned(val: u128, ty: UintTy, usize_ty: UintTy) -> Option<ConstInt> {
|
|
match ty {
|
|
UintTy::U8 if val <= ubounds::U8MAX => Some(U8(val as u8)),
|
|
UintTy::U16 if val <= ubounds::U16MAX => Some(U16(val as u16)),
|
|
UintTy::U32 if val <= ubounds::U32MAX => Some(U32(val as u32)),
|
|
UintTy::U64 if val <= ubounds::U64MAX => Some(U64(val as u64)),
|
|
UintTy::Usize if val <= ubounds::U64MAX => ConstUsize::new(val as u64, usize_ty).ok()
|
|
.map(Usize),
|
|
UintTy::U128 => Some(U128(val)),
|
|
_ => None
|
|
}
|
|
}
|
|
|
|
/// Creates a new signed ConstInt with matching type while also checking that overflow does
|
|
/// not happen.
|
|
pub fn new_signed(val: i128, ty: IntTy, isize_ty: IntTy) -> Option<ConstInt> {
|
|
match ty {
|
|
IntTy::I8 if val <= ibounds::I8MAX => Some(I8(val as i8)),
|
|
IntTy::I16 if val <= ibounds::I16MAX => Some(I16(val as i16)),
|
|
IntTy::I32 if val <= ibounds::I32MAX => Some(I32(val as i32)),
|
|
IntTy::I64 if val <= ibounds::I64MAX => Some(I64(val as i64)),
|
|
IntTy::Isize if val <= ibounds::I64MAX => ConstIsize::new(val as i64, isize_ty).ok()
|
|
.map(Isize),
|
|
IntTy::I128 => Some(I128(val)),
|
|
_ => None
|
|
}
|
|
}
|
|
|
|
/// Creates a new unsigned ConstInt with matching type.
|
|
pub fn new_unsigned_truncating(val: u128, ty: UintTy, usize_ty: UintTy) -> ConstInt {
|
|
match ty {
|
|
UintTy::U8 => U8(val as u8),
|
|
UintTy::U16 => U16(val as u16),
|
|
UintTy::U32 => U32(val as u32),
|
|
UintTy::U64 => U64(val as u64),
|
|
UintTy::Usize => Usize(ConstUsize::new_truncating(val, usize_ty)),
|
|
UintTy::U128 => U128(val)
|
|
}
|
|
}
|
|
|
|
/// Creates a new signed ConstInt with matching type.
|
|
pub fn new_signed_truncating(val: i128, ty: IntTy, isize_ty: IntTy) -> ConstInt {
|
|
match ty {
|
|
IntTy::I8 => I8(val as i8),
|
|
IntTy::I16 => I16(val as i16),
|
|
IntTy::I32 => I32(val as i32),
|
|
IntTy::I64 => I64(val as i64),
|
|
IntTy::Isize => Isize(ConstIsize::new_truncating(val, isize_ty)),
|
|
IntTy::I128 => I128(val)
|
|
}
|
|
}
|
|
|
|
/// Description of the type, not the value
|
|
pub fn description(&self) -> &'static str {
|
|
match *self {
|
|
I8(_) => "i8",
|
|
I16(_) => "i16",
|
|
I32(_) => "i32",
|
|
I64(_) => "i64",
|
|
I128(_) => "i128",
|
|
Isize(_) => "isize",
|
|
U8(_) => "u8",
|
|
U16(_) => "u16",
|
|
U32(_) => "u32",
|
|
U64(_) => "u64",
|
|
U128(_) => "u128",
|
|
Usize(_) => "usize",
|
|
}
|
|
}
|
|
|
|
/// Erases the type and returns a u128.
|
|
/// This is not the same as `-5i8 as u128` but as `-5i8 as i128 as u128`
|
|
pub fn to_u128_unchecked(self) -> u128 {
|
|
match self {
|
|
I8(i) => i as i128 as u128,
|
|
I16(i) => i as i128 as u128,
|
|
I32(i) => i as i128 as u128,
|
|
I64(i) => i as i128 as u128,
|
|
I128(i) => i as i128 as u128,
|
|
Isize(Is16(i)) => i as i128 as u128,
|
|
Isize(Is32(i)) => i as i128 as u128,
|
|
Isize(Is64(i)) => i as i128 as u128,
|
|
U8(i) => i as u128,
|
|
U16(i) => i as u128,
|
|
U32(i) => i as u128,
|
|
U64(i) => i as u128,
|
|
U128(i) => i as u128,
|
|
Usize(Us16(i)) => i as u128,
|
|
Usize(Us32(i)) => i as u128,
|
|
Usize(Us64(i)) => i as u128,
|
|
}
|
|
}
|
|
|
|
/// Converts the value to a `u32` if it's in the range 0...std::u32::MAX
|
|
pub fn to_u32(&self) -> Option<u32> {
|
|
self.to_u128().and_then(|v| if v <= u32::max_value() as u128 {
|
|
Some(v as u32)
|
|
} else {
|
|
None
|
|
})
|
|
}
|
|
|
|
/// Converts the value to a `u64` if it's in the range 0...std::u64::MAX
|
|
pub fn to_u64(&self) -> Option<u64> {
|
|
self.to_u128().and_then(|v| if v <= u64::max_value() as u128 {
|
|
Some(v as u64)
|
|
} else {
|
|
None
|
|
})
|
|
}
|
|
|
|
/// Converts the value to a `u128` if it's in the range 0...std::u128::MAX
|
|
pub fn to_u128(&self) -> Option<u128> {
|
|
match *self {
|
|
I8(v) if v >= 0 => Some(v as u128),
|
|
I16(v) if v >= 0 => Some(v as u128),
|
|
I32(v) if v >= 0 => Some(v as u128),
|
|
I64(v) if v >= 0 => Some(v as u128),
|
|
I128(v) if v >= 0 => Some(v as u128),
|
|
Isize(Is16(v)) if v >= 0 => Some(v as u128),
|
|
Isize(Is32(v)) if v >= 0 => Some(v as u128),
|
|
Isize(Is64(v)) if v >= 0 => Some(v as u128),
|
|
U8(v) => Some(v as u128),
|
|
U16(v) => Some(v as u128),
|
|
U32(v) => Some(v as u128),
|
|
U64(v) => Some(v as u128),
|
|
U128(v) => Some(v as u128),
|
|
Usize(Us16(v)) => Some(v as u128),
|
|
Usize(Us32(v)) => Some(v as u128),
|
|
Usize(Us64(v)) => Some(v as u128),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn is_negative(&self) -> bool {
|
|
match *self {
|
|
I8(v) => v < 0,
|
|
I16(v) => v < 0,
|
|
I32(v) => v < 0,
|
|
I64(v) => v < 0,
|
|
I128(v) => v < 0,
|
|
Isize(Is16(v)) => v < 0,
|
|
Isize(Is32(v)) => v < 0,
|
|
Isize(Is64(v)) => v < 0,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
/// Compares the values if they are of the same type
|
|
pub fn try_cmp(self, rhs: Self) -> Result<::std::cmp::Ordering, ConstMathErr> {
|
|
match (self, rhs) {
|
|
(I8(a), I8(b)) => Ok(a.cmp(&b)),
|
|
(I16(a), I16(b)) => Ok(a.cmp(&b)),
|
|
(I32(a), I32(b)) => Ok(a.cmp(&b)),
|
|
(I64(a), I64(b)) => Ok(a.cmp(&b)),
|
|
(I128(a), I128(b)) => Ok(a.cmp(&b)),
|
|
(Isize(Is16(a)), Isize(Is16(b))) => Ok(a.cmp(&b)),
|
|
(Isize(Is32(a)), Isize(Is32(b))) => Ok(a.cmp(&b)),
|
|
(Isize(Is64(a)), Isize(Is64(b))) => Ok(a.cmp(&b)),
|
|
(U8(a), U8(b)) => Ok(a.cmp(&b)),
|
|
(U16(a), U16(b)) => Ok(a.cmp(&b)),
|
|
(U32(a), U32(b)) => Ok(a.cmp(&b)),
|
|
(U64(a), U64(b)) => Ok(a.cmp(&b)),
|
|
(U128(a), U128(b)) => Ok(a.cmp(&b)),
|
|
(Usize(Us16(a)), Usize(Us16(b))) => Ok(a.cmp(&b)),
|
|
(Usize(Us32(a)), Usize(Us32(b))) => Ok(a.cmp(&b)),
|
|
(Usize(Us64(a)), Usize(Us64(b))) => Ok(a.cmp(&b)),
|
|
_ => Err(CmpBetweenUnequalTypes),
|
|
}
|
|
}
|
|
|
|
/// Adds 1 to the value and wraps around if the maximum for the type is reached
|
|
pub fn wrap_incr(self) -> Self {
|
|
macro_rules! add1 {
|
|
($e:expr) => { ($e).wrapping_add(1) }
|
|
}
|
|
match self {
|
|
ConstInt::I8(i) => ConstInt::I8(add1!(i)),
|
|
ConstInt::I16(i) => ConstInt::I16(add1!(i)),
|
|
ConstInt::I32(i) => ConstInt::I32(add1!(i)),
|
|
ConstInt::I64(i) => ConstInt::I64(add1!(i)),
|
|
ConstInt::I128(i) => ConstInt::I128(add1!(i)),
|
|
ConstInt::Isize(ConstIsize::Is16(i)) => ConstInt::Isize(ConstIsize::Is16(add1!(i))),
|
|
ConstInt::Isize(ConstIsize::Is32(i)) => ConstInt::Isize(ConstIsize::Is32(add1!(i))),
|
|
ConstInt::Isize(ConstIsize::Is64(i)) => ConstInt::Isize(ConstIsize::Is64(add1!(i))),
|
|
ConstInt::U8(i) => ConstInt::U8(add1!(i)),
|
|
ConstInt::U16(i) => ConstInt::U16(add1!(i)),
|
|
ConstInt::U32(i) => ConstInt::U32(add1!(i)),
|
|
ConstInt::U64(i) => ConstInt::U64(add1!(i)),
|
|
ConstInt::U128(i) => ConstInt::U128(add1!(i)),
|
|
ConstInt::Usize(ConstUsize::Us16(i)) => ConstInt::Usize(ConstUsize::Us16(add1!(i))),
|
|
ConstInt::Usize(ConstUsize::Us32(i)) => ConstInt::Usize(ConstUsize::Us32(add1!(i))),
|
|
ConstInt::Usize(ConstUsize::Us64(i)) => ConstInt::Usize(ConstUsize::Us64(add1!(i))),
|
|
}
|
|
}
|
|
|
|
pub fn int_type(self) -> IntType {
|
|
match self {
|
|
ConstInt::I8(_) => IntType::SignedInt(IntTy::I8),
|
|
ConstInt::I16(_) => IntType::SignedInt(IntTy::I16),
|
|
ConstInt::I32(_) => IntType::SignedInt(IntTy::I32),
|
|
ConstInt::I64(_) => IntType::SignedInt(IntTy::I64),
|
|
ConstInt::I128(_) => IntType::SignedInt(IntTy::I128),
|
|
ConstInt::Isize(_) => IntType::SignedInt(IntTy::Isize),
|
|
ConstInt::U8(_) => IntType::UnsignedInt(UintTy::U8),
|
|
ConstInt::U16(_) => IntType::UnsignedInt(UintTy::U16),
|
|
ConstInt::U32(_) => IntType::UnsignedInt(UintTy::U32),
|
|
ConstInt::U64(_) => IntType::UnsignedInt(UintTy::U64),
|
|
ConstInt::U128(_) => IntType::UnsignedInt(UintTy::U128),
|
|
ConstInt::Usize(_) => IntType::UnsignedInt(UintTy::Usize),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ::std::cmp::PartialOrd for ConstInt {
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
self.try_cmp(*other).ok()
|
|
}
|
|
}
|
|
|
|
impl ::std::cmp::Ord for ConstInt {
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
self.try_cmp(*other).unwrap()
|
|
}
|
|
}
|
|
|
|
impl ::std::fmt::Display for ConstInt {
|
|
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
|
|
match *self {
|
|
I8(i) => write!(fmt, "{}i8", i),
|
|
I16(i) => write!(fmt, "{}i16", i),
|
|
I32(i) => write!(fmt, "{}i32", i),
|
|
I64(i) => write!(fmt, "{}i64", i),
|
|
I128(i) => write!(fmt, "{}i128", i),
|
|
Isize(i) => write!(fmt, "{}isize", i),
|
|
U8(i) => write!(fmt, "{}u8", i),
|
|
U16(i) => write!(fmt, "{}u16", i),
|
|
U32(i) => write!(fmt, "{}u32", i),
|
|
U64(i) => write!(fmt, "{}u64", i),
|
|
U128(i) => write!(fmt, "{}u128", i),
|
|
Usize(i) => write!(fmt, "{}usize", i),
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! overflowing {
|
|
($e:expr, $err:expr) => {{
|
|
if $e.1 {
|
|
return Err(Overflow($err));
|
|
} else {
|
|
$e.0
|
|
}
|
|
}}
|
|
}
|
|
|
|
macro_rules! impl_binop {
|
|
($op:ident, $func:ident, $checked_func:ident) => {
|
|
impl ::std::ops::$op for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn $func(self, rhs: Self) -> Result<Self, ConstMathErr> {
|
|
match (self, rhs) {
|
|
(I8(a), I8(b)) => a.$checked_func(b).map(I8),
|
|
(I16(a), I16(b)) => a.$checked_func(b).map(I16),
|
|
(I32(a), I32(b)) => a.$checked_func(b).map(I32),
|
|
(I64(a), I64(b)) => a.$checked_func(b).map(I64),
|
|
(I128(a), I128(b)) => a.$checked_func(b).map(I128),
|
|
(Isize(Is16(a)), Isize(Is16(b))) => a.$checked_func(b).map(Is16).map(Isize),
|
|
(Isize(Is32(a)), Isize(Is32(b))) => a.$checked_func(b).map(Is32).map(Isize),
|
|
(Isize(Is64(a)), Isize(Is64(b))) => a.$checked_func(b).map(Is64).map(Isize),
|
|
(U8(a), U8(b)) => a.$checked_func(b).map(U8),
|
|
(U16(a), U16(b)) => a.$checked_func(b).map(U16),
|
|
(U32(a), U32(b)) => a.$checked_func(b).map(U32),
|
|
(U64(a), U64(b)) => a.$checked_func(b).map(U64),
|
|
(U128(a), U128(b)) => a.$checked_func(b).map(U128),
|
|
(Usize(Us16(a)), Usize(Us16(b))) => a.$checked_func(b).map(Us16).map(Usize),
|
|
(Usize(Us32(a)), Usize(Us32(b))) => a.$checked_func(b).map(Us32).map(Usize),
|
|
(Usize(Us64(a)), Usize(Us64(b))) => a.$checked_func(b).map(Us64).map(Usize),
|
|
_ => return Err(UnequalTypes(Op::$op)),
|
|
}.ok_or(Overflow(Op::$op))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! derive_binop {
|
|
($op:ident, $func:ident) => {
|
|
impl ::std::ops::$op for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn $func(self, rhs: Self) -> Result<Self, ConstMathErr> {
|
|
match (self, rhs) {
|
|
(I8(a), I8(b)) => Ok(I8(a.$func(b))),
|
|
(I16(a), I16(b)) => Ok(I16(a.$func(b))),
|
|
(I32(a), I32(b)) => Ok(I32(a.$func(b))),
|
|
(I64(a), I64(b)) => Ok(I64(a.$func(b))),
|
|
(I128(a), I128(b)) => Ok(I128(a.$func(b))),
|
|
(Isize(Is16(a)), Isize(Is16(b))) => Ok(Isize(Is16(a.$func(b)))),
|
|
(Isize(Is32(a)), Isize(Is32(b))) => Ok(Isize(Is32(a.$func(b)))),
|
|
(Isize(Is64(a)), Isize(Is64(b))) => Ok(Isize(Is64(a.$func(b)))),
|
|
(U8(a), U8(b)) => Ok(U8(a.$func(b))),
|
|
(U16(a), U16(b)) => Ok(U16(a.$func(b))),
|
|
(U32(a), U32(b)) => Ok(U32(a.$func(b))),
|
|
(U64(a), U64(b)) => Ok(U64(a.$func(b))),
|
|
(U128(a), U128(b)) => Ok(U128(a.$func(b))),
|
|
(Usize(Us16(a)), Usize(Us16(b))) => Ok(Usize(Us16(a.$func(b)))),
|
|
(Usize(Us32(a)), Usize(Us32(b))) => Ok(Usize(Us32(a.$func(b)))),
|
|
(Usize(Us64(a)), Usize(Us64(b))) => Ok(Usize(Us64(a.$func(b)))),
|
|
_ => Err(UnequalTypes(Op::$op)),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_binop!(Add, add, checked_add);
|
|
impl_binop!(Sub, sub, checked_sub);
|
|
impl_binop!(Mul, mul, checked_mul);
|
|
derive_binop!(BitAnd, bitand);
|
|
derive_binop!(BitOr, bitor);
|
|
derive_binop!(BitXor, bitxor);
|
|
|
|
const I128_MIN: i128 = ::std::i128::MIN;
|
|
|
|
fn check_division(
|
|
lhs: ConstInt,
|
|
rhs: ConstInt,
|
|
op: Op,
|
|
zerr: ConstMathErr,
|
|
) -> Result<(), ConstMathErr> {
|
|
match (lhs, rhs) {
|
|
(I8(_), I8(0)) => Err(zerr),
|
|
(I16(_), I16(0)) => Err(zerr),
|
|
(I32(_), I32(0)) => Err(zerr),
|
|
(I64(_), I64(0)) => Err(zerr),
|
|
(I128(_), I128(0)) => Err(zerr),
|
|
(Isize(_), Isize(Is16(0))) => Err(zerr),
|
|
(Isize(_), Isize(Is32(0))) => Err(zerr),
|
|
(Isize(_), Isize(Is64(0))) => Err(zerr),
|
|
|
|
(U8(_), U8(0)) => Err(zerr),
|
|
(U16(_), U16(0)) => Err(zerr),
|
|
(U32(_), U32(0)) => Err(zerr),
|
|
(U64(_), U64(0)) => Err(zerr),
|
|
(U128(_), U128(0)) => Err(zerr),
|
|
(Usize(_), Usize(Us16(0))) => Err(zerr),
|
|
(Usize(_), Usize(Us32(0))) => Err(zerr),
|
|
(Usize(_), Usize(Us64(0))) => Err(zerr),
|
|
|
|
(I8(::std::i8::MIN), I8(-1)) => Err(Overflow(op)),
|
|
(I16(::std::i16::MIN), I16(-1)) => Err(Overflow(op)),
|
|
(I32(::std::i32::MIN), I32(-1)) => Err(Overflow(op)),
|
|
(I64(::std::i64::MIN), I64(-1)) => Err(Overflow(op)),
|
|
(I128(I128_MIN), I128(-1)) => Err(Overflow(op)),
|
|
(Isize(Is16(::std::i16::MIN)), Isize(Is16(-1))) => Err(Overflow(op)),
|
|
(Isize(Is32(::std::i32::MIN)), Isize(Is32(-1))) => Err(Overflow(op)),
|
|
(Isize(Is64(::std::i64::MIN)), Isize(Is64(-1))) => Err(Overflow(op)),
|
|
|
|
_ => Ok(()),
|
|
}
|
|
}
|
|
|
|
impl ::std::ops::Div for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn div(self, rhs: Self) -> Result<Self, ConstMathErr> {
|
|
let (lhs, rhs) = (self, rhs);
|
|
check_division(lhs, rhs, Op::Div, DivisionByZero)?;
|
|
match (lhs, rhs) {
|
|
(I8(a), I8(b)) => Ok(I8(a/b)),
|
|
(I16(a), I16(b)) => Ok(I16(a/b)),
|
|
(I32(a), I32(b)) => Ok(I32(a/b)),
|
|
(I64(a), I64(b)) => Ok(I64(a/b)),
|
|
(I128(a), I128(b)) => Ok(I128(a/b)),
|
|
(Isize(Is16(a)), Isize(Is16(b))) => Ok(Isize(Is16(a/b))),
|
|
(Isize(Is32(a)), Isize(Is32(b))) => Ok(Isize(Is32(a/b))),
|
|
(Isize(Is64(a)), Isize(Is64(b))) => Ok(Isize(Is64(a/b))),
|
|
|
|
(U8(a), U8(b)) => Ok(U8(a/b)),
|
|
(U16(a), U16(b)) => Ok(U16(a/b)),
|
|
(U32(a), U32(b)) => Ok(U32(a/b)),
|
|
(U64(a), U64(b)) => Ok(U64(a/b)),
|
|
(U128(a), U128(b)) => Ok(U128(a/b)),
|
|
(Usize(Us16(a)), Usize(Us16(b))) => Ok(Usize(Us16(a/b))),
|
|
(Usize(Us32(a)), Usize(Us32(b))) => Ok(Usize(Us32(a/b))),
|
|
(Usize(Us64(a)), Usize(Us64(b))) => Ok(Usize(Us64(a/b))),
|
|
|
|
_ => Err(UnequalTypes(Op::Div)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ::std::ops::Rem for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn rem(self, rhs: Self) -> Result<Self, ConstMathErr> {
|
|
let (lhs, rhs) = (self, rhs);
|
|
// should INT_MIN%-1 be zero or an error?
|
|
check_division(lhs, rhs, Op::Rem, RemainderByZero)?;
|
|
match (lhs, rhs) {
|
|
(I8(a), I8(b)) => Ok(I8(a%b)),
|
|
(I16(a), I16(b)) => Ok(I16(a%b)),
|
|
(I32(a), I32(b)) => Ok(I32(a%b)),
|
|
(I64(a), I64(b)) => Ok(I64(a%b)),
|
|
(I128(a), I128(b)) => Ok(I128(a%b)),
|
|
(Isize(Is16(a)), Isize(Is16(b))) => Ok(Isize(Is16(a%b))),
|
|
(Isize(Is32(a)), Isize(Is32(b))) => Ok(Isize(Is32(a%b))),
|
|
(Isize(Is64(a)), Isize(Is64(b))) => Ok(Isize(Is64(a%b))),
|
|
|
|
(U8(a), U8(b)) => Ok(U8(a%b)),
|
|
(U16(a), U16(b)) => Ok(U16(a%b)),
|
|
(U32(a), U32(b)) => Ok(U32(a%b)),
|
|
(U64(a), U64(b)) => Ok(U64(a%b)),
|
|
(U128(a), U128(b)) => Ok(U128(a%b)),
|
|
(Usize(Us16(a)), Usize(Us16(b))) => Ok(Usize(Us16(a%b))),
|
|
(Usize(Us32(a)), Usize(Us32(b))) => Ok(Usize(Us32(a%b))),
|
|
(Usize(Us64(a)), Usize(Us64(b))) => Ok(Usize(Us64(a%b))),
|
|
|
|
_ => Err(UnequalTypes(Op::Rem)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ::std::ops::Shl<ConstInt> for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn shl(self, rhs: Self) -> Result<Self, ConstMathErr> {
|
|
let b = rhs.to_u32().ok_or(ShiftNegative)?;
|
|
match self {
|
|
I8(a) => Ok(I8(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
I16(a) => Ok(I16(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
I32(a) => Ok(I32(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
I64(a) => Ok(I64(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
I128(a) => Ok(I128(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
Isize(Is16(a)) => Ok(Isize(Is16(overflowing!(a.overflowing_shl(b), Op::Shl)))),
|
|
Isize(Is32(a)) => Ok(Isize(Is32(overflowing!(a.overflowing_shl(b), Op::Shl)))),
|
|
Isize(Is64(a)) => Ok(Isize(Is64(overflowing!(a.overflowing_shl(b), Op::Shl)))),
|
|
U8(a) => Ok(U8(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
U16(a) => Ok(U16(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
U32(a) => Ok(U32(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
U64(a) => Ok(U64(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
U128(a) => Ok(U128(overflowing!(a.overflowing_shl(b), Op::Shl))),
|
|
Usize(Us16(a)) => Ok(Usize(Us16(overflowing!(a.overflowing_shl(b), Op::Shl)))),
|
|
Usize(Us32(a)) => Ok(Usize(Us32(overflowing!(a.overflowing_shl(b), Op::Shl)))),
|
|
Usize(Us64(a)) => Ok(Usize(Us64(overflowing!(a.overflowing_shl(b), Op::Shl)))),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ::std::ops::Shr<ConstInt> for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn shr(self, rhs: Self) -> Result<Self, ConstMathErr> {
|
|
let b = rhs.to_u32().ok_or(ShiftNegative)?;
|
|
match self {
|
|
I8(a) => Ok(I8(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
I16(a) => Ok(I16(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
I32(a) => Ok(I32(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
I64(a) => Ok(I64(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
I128(a) => Ok(I128(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
Isize(Is16(a)) => Ok(Isize(Is16(overflowing!(a.overflowing_shr(b), Op::Shr)))),
|
|
Isize(Is32(a)) => Ok(Isize(Is32(overflowing!(a.overflowing_shr(b), Op::Shr)))),
|
|
Isize(Is64(a)) => Ok(Isize(Is64(overflowing!(a.overflowing_shr(b), Op::Shr)))),
|
|
U8(a) => Ok(U8(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
U16(a) => Ok(U16(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
U32(a) => Ok(U32(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
U64(a) => Ok(U64(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
U128(a) => Ok(U128(overflowing!(a.overflowing_shr(b), Op::Shr))),
|
|
Usize(Us16(a)) => Ok(Usize(Us16(overflowing!(a.overflowing_shr(b), Op::Shr)))),
|
|
Usize(Us32(a)) => Ok(Usize(Us32(overflowing!(a.overflowing_shr(b), Op::Shr)))),
|
|
Usize(Us64(a)) => Ok(Usize(Us64(overflowing!(a.overflowing_shr(b), Op::Shr)))),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ::std::ops::Neg for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn neg(self) -> Result<Self, ConstMathErr> {
|
|
match self {
|
|
I8(a) => Ok(I8(overflowing!(a.overflowing_neg(), Op::Neg))),
|
|
I16(a) => Ok(I16(overflowing!(a.overflowing_neg(), Op::Neg))),
|
|
I32(a) => Ok(I32(overflowing!(a.overflowing_neg(), Op::Neg))),
|
|
I64(a) => Ok(I64(overflowing!(a.overflowing_neg(), Op::Neg))),
|
|
I128(a) => Ok(I128(overflowing!(a.overflowing_neg(), Op::Neg))),
|
|
Isize(Is16(a)) => Ok(Isize(Is16(overflowing!(a.overflowing_neg(), Op::Neg)))),
|
|
Isize(Is32(a)) => Ok(Isize(Is32(overflowing!(a.overflowing_neg(), Op::Neg)))),
|
|
Isize(Is64(a)) => Ok(Isize(Is64(overflowing!(a.overflowing_neg(), Op::Neg)))),
|
|
a@U8(0) | a@U16(0) | a@U32(0) | a@U64(0) | a@U128(0) |
|
|
a@Usize(Us16(0)) | a@Usize(Us32(0)) | a@Usize(Us64(0)) => Ok(a),
|
|
U8(_) | U16(_) | U32(_) | U64(_) | U128(_) | Usize(_) => Err(UnsignedNegation),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ::std::ops::Not for ConstInt {
|
|
type Output = Result<Self, ConstMathErr>;
|
|
fn not(self) -> Result<Self, ConstMathErr> {
|
|
match self {
|
|
I8(a) => Ok(I8(!a)),
|
|
I16(a) => Ok(I16(!a)),
|
|
I32(a) => Ok(I32(!a)),
|
|
I64(a) => Ok(I64(!a)),
|
|
I128(a) => Ok(I128(!a)),
|
|
Isize(Is16(a)) => Ok(Isize(Is16(!a))),
|
|
Isize(Is32(a)) => Ok(Isize(Is32(!a))),
|
|
Isize(Is64(a)) => Ok(Isize(Is64(!a))),
|
|
U8(a) => Ok(U8(!a)),
|
|
U16(a) => Ok(U16(!a)),
|
|
U32(a) => Ok(U32(!a)),
|
|
U64(a) => Ok(U64(!a)),
|
|
U128(a) => Ok(U128(!a)),
|
|
Usize(Us16(a)) => Ok(Usize(Us16(!a))),
|
|
Usize(Us32(a)) => Ok(Usize(Us32(!a))),
|
|
Usize(Us64(a)) => Ok(Usize(Us64(!a))),
|
|
}
|
|
}
|
|
}
|