2020-04-21 17:01:10 +02:00
|
|
|
use super::{reg_binary, reg_binary_mut, reg_unary};
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
use crate::def_package;
|
2020-04-20 18:11:25 +02:00
|
|
|
use crate::fn_register::map_dynamic as map;
|
|
|
|
use crate::parser::INT;
|
|
|
|
|
2020-04-24 06:39:24 +02:00
|
|
|
use crate::stdlib::string::String;
|
|
|
|
|
2020-04-20 18:11:25 +02:00
|
|
|
// Comparison operators
|
|
|
|
pub fn lt<T: PartialOrd>(x: T, y: T) -> bool {
|
|
|
|
x < y
|
|
|
|
}
|
|
|
|
pub fn lte<T: PartialOrd>(x: T, y: T) -> bool {
|
|
|
|
x <= y
|
|
|
|
}
|
|
|
|
pub fn gt<T: PartialOrd>(x: T, y: T) -> bool {
|
|
|
|
x > y
|
|
|
|
}
|
|
|
|
pub fn gte<T: PartialOrd>(x: T, y: T) -> bool {
|
|
|
|
x >= y
|
|
|
|
}
|
|
|
|
pub fn eq<T: PartialEq>(x: T, y: T) -> bool {
|
|
|
|
x == y
|
|
|
|
}
|
|
|
|
pub fn ne<T: PartialEq>(x: T, y: T) -> bool {
|
|
|
|
x != y
|
|
|
|
}
|
|
|
|
|
|
|
|
// Logic operators
|
|
|
|
fn and(x: bool, y: bool) -> bool {
|
|
|
|
x && y
|
|
|
|
}
|
|
|
|
fn or(x: bool, y: bool) -> bool {
|
|
|
|
x || y
|
|
|
|
}
|
|
|
|
fn not(x: bool) -> bool {
|
|
|
|
!x
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! reg_op { ($lib:expr, $op:expr, $func:ident, $($par:ty),*) => {
|
|
|
|
$(reg_binary($lib, $op, $func::<$par>, map);)* };
|
|
|
|
}
|
|
|
|
|
2020-04-22 08:55:40 +02:00
|
|
|
def_package!(crate:LogicPackage:"Logical operators.", lib, {
|
2020-04-21 17:01:10 +02:00
|
|
|
reg_op!(lib, "<", lt, INT, char);
|
|
|
|
reg_op!(lib, "<=", lte, INT, char);
|
|
|
|
reg_op!(lib, ">", gt, INT, char);
|
|
|
|
reg_op!(lib, ">=", gte, INT, char);
|
|
|
|
reg_op!(lib, "==", eq, INT, char, bool, ());
|
|
|
|
reg_op!(lib, "!=", ne, INT, char, bool, ());
|
|
|
|
|
|
|
|
// Special versions for strings - at least avoid copying the first string
|
2020-04-23 07:23:25 +02:00
|
|
|
// use super::utils::reg_test;
|
|
|
|
// reg_test(lib, "<", |x: &mut String, y: String| *x < y, |v| v, map);
|
2020-04-21 17:01:10 +02:00
|
|
|
reg_binary_mut(lib, "<", |x: &mut String, y: String| *x < y, map);
|
|
|
|
reg_binary_mut(lib, "<=", |x: &mut String, y: String| *x <= y, map);
|
|
|
|
reg_binary_mut(lib, ">", |x: &mut String, y: String| *x > y, map);
|
|
|
|
reg_binary_mut(lib, ">=", |x: &mut String, y: String| *x >= y, map);
|
|
|
|
reg_binary_mut(lib, "==", |x: &mut String, y: String| *x == y, map);
|
|
|
|
reg_binary_mut(lib, "!=", |x: &mut String, y: String| *x != y, map);
|
|
|
|
|
|
|
|
#[cfg(not(feature = "only_i32"))]
|
|
|
|
#[cfg(not(feature = "only_i64"))]
|
|
|
|
{
|
|
|
|
reg_op!(lib, "<", lt, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
|
|
|
|
reg_op!(lib, "<=", lte, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
|
|
|
|
reg_op!(lib, ">", gt, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
|
|
|
|
reg_op!(lib, ">=", gte, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
|
|
|
|
reg_op!(lib, "==", eq, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
|
|
|
|
reg_op!(lib, "!=", ne, i8, u8, i16, u16, i32, i64, u32, u64, i128, u128);
|
2020-04-20 18:11:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
#[cfg(not(feature = "no_float"))]
|
|
|
|
{
|
|
|
|
reg_op!(lib, "<", lt, f32, f64);
|
|
|
|
reg_op!(lib, "<=", lte, f32, f64);
|
|
|
|
reg_op!(lib, ">", gt, f32, f64);
|
|
|
|
reg_op!(lib, ">=", gte, f32, f64);
|
|
|
|
reg_op!(lib, "==", eq, f32, f64);
|
|
|
|
reg_op!(lib, "!=", ne, f32, f64);
|
2020-04-20 18:11:25 +02:00
|
|
|
}
|
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
// `&&` and `||` are treated specially as they short-circuit.
|
|
|
|
// They are implemented as special `Expr` instances, not function calls.
|
|
|
|
//reg_op!(lib, "||", or, bool);
|
|
|
|
//reg_op!(lib, "&&", and, bool);
|
2020-04-20 18:11:25 +02:00
|
|
|
|
2020-04-21 17:01:10 +02:00
|
|
|
reg_binary(lib, "|", or, map);
|
|
|
|
reg_binary(lib, "&", and, map);
|
|
|
|
reg_unary(lib, "!", not, map);
|
|
|
|
});
|