meebis 0.15.0

A fast, disposable, in-memory Redis-compatible server for ephemeral dev work
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

//! A Rust reimplementation of the `bit` library (Lua BitOp) Redis exposes to
//! scripts. All operations work on 32-bit values and return signed 32-bit
//! results, matching Lua BitOp's semantics on a Lua 5.1 (double) runtime.

use mlua::{Lua, Result, Variadic};

/// Register the global `bit` table.
pub(super) fn register(lua: &Lua) -> Result<()> {
    let bit = lua.create_table()?;

    bit.set("tobit", lua.create_function(|_, x: f64| Ok(tobit(x)))?)?;
    bit.set("bnot", lua.create_function(|_, x: f64| Ok(!tobit(x)))?)?;

    bit.set(
        "band",
        lua.create_function(|_, xs: Variadic<f64>| Ok(fold(xs, -1, |a, b| a & b)))?,
    )?;
    bit.set(
        "bor",
        lua.create_function(|_, xs: Variadic<f64>| Ok(fold(xs, 0, |a, b| a | b)))?,
    )?;
    bit.set(
        "bxor",
        lua.create_function(|_, xs: Variadic<f64>| Ok(fold(xs, 0, |a, b| a ^ b)))?,
    )?;

    bit.set(
        "lshift",
        lua.create_function(|_, (x, n): (f64, i64)| Ok(((tobit(x) as u32) << (n & 31)) as i32))?,
    )?;
    bit.set(
        "rshift",
        lua.create_function(|_, (x, n): (f64, i64)| Ok(((tobit(x) as u32) >> (n & 31)) as i32))?,
    )?;
    bit.set(
        "arshift",
        lua.create_function(|_, (x, n): (f64, i64)| Ok(tobit(x) >> (n & 31)))?,
    )?;
    bit.set(
        "rol",
        lua.create_function(|_, (x, n): (f64, i64)| Ok(tobit(x).rotate_left((n & 31) as u32)))?,
    )?;
    bit.set(
        "ror",
        lua.create_function(|_, (x, n): (f64, i64)| Ok(tobit(x).rotate_right((n & 31) as u32)))?,
    )?;
    bit.set(
        "bswap",
        lua.create_function(|_, x: f64| Ok(tobit(x).swap_bytes()))?,
    )?;

    bit.set(
        "tohex",
        lua.create_function(|_, (x, n): (f64, Option<i64>)| Ok(tohex(x, n)))?,
    )?;

    lua.globals().set("bit", bit)?;
    Ok(())
}

/// Normalise a Lua number to a signed 32-bit integer, as `bit.tobit` does.
fn tobit(x: f64) -> i32 {
    x as i64 as u32 as i32
}

fn fold(xs: Variadic<f64>, init: i32, op: fn(i32, i32) -> i32) -> i32 {
    xs.iter().fold(init, |acc, &x| op(acc, tobit(x)))
}

fn tohex(x: f64, n: Option<i64>) -> String {
    let digits = n.unwrap_or(8);
    let width = (digits.unsigned_abs() as usize).min(8);
    let value = (tobit(x) as u32) as u64;
    let hex = if digits < 0 {
        format!("{value:08X}")
    } else {
        format!("{value:08x}")
    };
    // Keep the low `width` nibbles (BitOp shows the least-significant digits).
    hex[hex.len() - width..].to_string()
}