fluxvm 0.1.0

FLUX bytecode runtime — Fluid Language Universal eXecution: a zero-dependency register-based VM with assembler, disassembler, A2A agent protocol, and vocabulary system
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

use flux_core::vm::Interpreter;

#[test]
fn test_movi_halt() {
    let bc = [0x2B, 0x00, 0x2A, 0x00, 0x80]; // MOVI R0, 42; HALT
    let mut vm = Interpreter::new(&bc);
    vm.execute().unwrap();
    assert_eq!(vm.read_gp(0), 42);
}

#[test]
fn test_addition() {
    let bc = [0x2B, 0x00, 0x0A, 0x00,  // MOVI R0, 10
              0x2B, 0x01, 0x14, 0x00,  // MOVI R1, 20
              0x08, 0x00, 0x01,        // IADD R0, R1
              0x80];                   // HALT
    let mut vm = Interpreter::new(&bc);
    vm.execute().unwrap();
    assert_eq!(vm.read_gp(0), 30);
}

#[test]
fn test_multiplication() {
    let bc = [0x2B, 0x00, 0x06, 0x00,  // MOVI R0, 6
              0x2B, 0x01, 0x07, 0x00,  // MOVI R1, 7
              0x0A, 0x00, 0x01,        // IMUL R0, R1
              0x80];
    let mut vm = Interpreter::new(&bc);
    vm.execute().unwrap();
    assert_eq!(vm.read_gp(0), 42);
}

#[test]
fn test_loop_sum() {
    // Sum 1+2+...+10 = 55
    let bc = [0x2B, 0x00, 0x00, 0x00,  // MOVI R0, 0
              0x2B, 0x01, 0x0A, 0x00,  // MOVI R1, 10
              0x08, 0x00, 0x01,        // IADD R0, R1
              0x0F, 0x01,              // DEC R1
              0x06, 0x01, 0xF7, 0xFF,  // JNZ R1, -9
              0x80];
    let mut vm = Interpreter::new(&bc);
    vm.execute().unwrap();
    assert_eq!(vm.read_gp(0), 55);
}

#[test]
fn test_factorial() {
    // 5! = 120
    let bc = [0x2B, 0x03, 0x05, 0x00,  // MOVI R3, 5
              0x2B, 0x04, 0x01, 0x00,  // MOVI R4, 1
              0x0A, 0x04, 0x03,        // IMUL R4, R3
              0x0F, 0x03,              // DEC R3
              0x06, 0x03, 0xF7, 0xFF,  // JNZ R3, -9
              0x80];
    let mut vm = Interpreter::new(&bc);
    vm.execute().unwrap();
    assert_eq!(vm.read_gp(4), 120);
}

#[test]
fn test_division_by_zero() {
    let bc = [0x2B, 0x00, 0x0A, 0x00,  // MOVI R0, 10
              0x2B, 0x01, 0x00, 0x00,  // MOVI R1, 0
              0x0B, 0x00, 0x01,        // IDIV R0, R1
              0x80];
    let mut vm = Interpreter::new(&bc);
    let result = vm.execute();
    assert!(result.is_err());
}