hephasm 0.1.0

Assembler for Asmodeus architecture with macro support and extended instructions
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

use hephasm::assemble_source;

#[test]
fn test_complex_program() {
    let machine_code = assemble_source(r#"
        ; Simple program with data and labels
        start:
            POB value       ; Load value
            ŁAD result      ; Store in result
            STP             ; Stop
            
        value: RST 42
        result: RPA
    "#).unwrap();
    
    // assembles without errors?
    assert!(!machine_code.is_empty());
    assert_eq!(machine_code.len(), 5);
    
    // POB value (address 3) - direct addressing 
    let expected_pob = (0b00100u16 << 11) | (0b000u16 << 8) | 3;
    assert_eq!(machine_code[0], expected_pob);
    
    // ŁAD result (address 4) - direct addressing 
    let expected_lad = (0b00011u16 << 11) | (0b000u16 << 8) | 4;
    assert_eq!(machine_code[1], expected_lad);

    // STP - no operand, direct addressing with argument 0
    let expected_stp = (0b00111u16 << 11) | (0b000u16 << 8) | 0;
    assert_eq!(machine_code[2], expected_stp);
    
    // value: RST 42
    assert_eq!(machine_code[3], 42);
    
    // result: RPA
    assert_eq!(machine_code[4], 0);
}

#[test]
fn test_program_with_comments_and_whitespace() {
    let machine_code = assemble_source(r#"
        ; This is a test program
        start:          ; Main entry point
            DOD #10     ; Add immediate value 10
            STP         ; Stop execution
            
        ; Data section
        data: RST 42    ; Test data
    "#).unwrap();
    
    assert_eq!(machine_code.len(), 3);
    
    // DOD #10 - immediate addressing
    let expected_dod = (0b00001u16 << 11) | (0b001u16 << 8) | 10;
    assert_eq!(machine_code[0], expected_dod);
    
    // STP - no operand, direct addressing with argument 0
    let expected_stp = (0b00111u16 << 11) | (0b000u16 << 8) | 0;
    assert_eq!(machine_code[1], expected_stp);
    
    // data: RST 42
    assert_eq!(machine_code[2], 42);
}

#[test]
fn test_empty_program() {
    let machine_code = assemble_source("").unwrap();
    assert_eq!(machine_code.len(), 0);
}