luars 0.17.0

A library for lua 5.5 runtime implementation in Rust
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
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

// ============================================================
// Integer-Float comparison helpers (Lua 5.5 semantics)
// These handle the tricky edge cases where converting to f64
// loses precision (e.g., i64::MAX as f64 rounds to 2^63).
// ============================================================

use crate::{
    LuaValue,
    lua_vm::execute::helper::{ttisfloat, ttisinteger},
};

/// Is integer i less than float f?  (i < f)
/// Handles NaN, infinities, and precision loss at i64 boundaries.
#[inline]
pub fn int_lt_float(i: i64, f: f64) -> bool {
    if f.is_nan() {
        return false;
    }
    // i64::MAX as f64 = 2^63 (rounds up), so f >= 2^63 means f > any i64
    if f >= (i64::MAX as f64) {
        return true;
    }
    // i64::MIN as f64 = -2^63 (exact), so f < -2^63 means f < any i64
    if f < (i64::MIN as f64) {
        return false;
    }
    // f is in castable range: truncate toward zero
    let fi = f as i64;
    if i < fi {
        true
    } else if i > fi {
        false
    } else {
        // i == fi: true iff f has a positive fractional part beyond fi
        f > (fi as f64)
    }
}

/// Is float f less than integer i?  (f < i)
#[inline]
pub fn float_lt_int(f: f64, i: i64) -> bool {
    if f.is_nan() {
        return false;
    }
    if f >= (i64::MAX as f64) {
        return false;
    }
    if f < (i64::MIN as f64) {
        return true;
    }
    let fi = f as i64;
    if fi < i {
        true
    } else if fi > i {
        false
    } else {
        // fi == i: true iff f has a negative fractional part (truncated away)
        f < (fi as f64)
    }
}

/// Is integer i less than or equal to float f?  (i <= f)
#[inline]
pub fn int_le_float(i: i64, f: f64) -> bool {
    // NaN: i <= NaN is always false
    if f.is_nan() {
        return false;
    }
    !float_lt_int(f, i)
}

/// Is float f less than or equal to integer i?  (f <= i)
#[inline]
pub fn float_le_int(f: f64, i: i64) -> bool {
    // NaN: NaN <= i is always false
    if f.is_nan() {
        return false;
    }
    !int_lt_float(i, f)
}

pub fn lt_num(a: &LuaValue, b: &LuaValue) -> bool {
    if ttisinteger(a) {
        let ai = a.ivalue();
        if ttisinteger(b) {
            let bi = b.ivalue();
            ai < bi
        } else if ttisfloat(b) {
            int_lt_float(ai, b.fltvalue())
        } else {
            // unrecachable: caller should have ensured both are numbers
            false
        }
    } else {
        let af = a.fltvalue();
        if ttisfloat(b) {
            let bf = b.fltvalue();
            af < bf
        } else if ttisinteger(b) {
            float_lt_int(af, b.ivalue())
        } else {
            // unrecachable: caller should have ensured both are numbers
            false
        }
    }
}

pub fn le_num(a: &LuaValue, b: &LuaValue) -> bool {
    if ttisinteger(a) {
        let ai = a.ivalue();
        if ttisinteger(b) {
            let bi = b.ivalue();
            ai <= bi
        } else if ttisfloat(b) {
            int_le_float(ai, b.fltvalue())
        } else {
            // unrecachable: caller should have ensured both are numbers
            false
        }
    } else {
        let af = a.fltvalue();
        if ttisfloat(b) {
            let bf = b.fltvalue();
            af <= bf
        } else if ttisinteger(b) {
            float_le_int(af, b.ivalue())
        } else {
            // unrecachable: caller should have ensured both are numbers
            false
        }
    }
}