cpclib 0.11.0

Set of tools and libraries to ease demomaking on the Amstrad CPC platform. WIP
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
133

#[cfg(test)]
mod tests {
    use cpclib_asm::assembler::processed_token::build_processed_token;
    use cpclib_asm::preamble::*;

    fn visit_token(token: &Token, env: &mut Env) -> Result<(), AssemblerError> {
        let processed = build_processed_token(token, env);
        processed?.visited(env)
    }

    fn visit_tokens(tokens: &[Token]) -> Result<Env, AssemblerError> {
        let mut env = Env::default();
        for t in tokens {
            visit_token(t, &mut env)?;
        }
        Ok(env)
    }

    #[test]
    pub fn test_visit() {
        let mut env = Env::default();

        visit_token(
            &Token::Org {
                val1: Expr::Value(10),
                val2: None
            },
            &mut env
        )
        .unwrap();
        visit_token(
            &Token::Defb(vec![Expr::Value(10), Expr::Value(5)]),
            &mut env
        )
        .unwrap();
        visit_token(
            &Token::OpCode(
                Mnemonic::Ld,
                Some(DataAccess::Register8(Register8::A)),
                Some(DataAccess::Register8(Register8::L)),
                None
            ),
            &mut env
        )
        .unwrap();
    }

    #[test]
    pub fn test_ld() {
        let mut env = Env::default();
        assert_ne!(env.peek(&0x0000.into()), 0x7F);

        visit_token(
            &Token::OpCode(
                Mnemonic::Ld,
                Some(DataAccess::Register8(Register8::A)),
                Some(DataAccess::Register8(Register8::A)),
                None
            ),
            &mut env
        )
        .unwrap();
        assert_eq!(env.peek(&0x0000.into()), 0x7F);

        visit_token(
            &Token::OpCode(
                Mnemonic::Ld,
                Some(DataAccess::Register8(Register8::A)),
                Some(DataAccess::Register8(Register8::L)),
                None
            ),
            &mut env
        )
        .unwrap();
        assert_eq!(env.peek(&0x0001.into()), 0x7D);

        visit_token(
            &Token::OpCode(
                Mnemonic::Ld,
                Some(DataAccess::Register8(Register8::C)),
                Some(DataAccess::Register8(Register8::C)),
                None
            ),
            &mut env
        )
        .unwrap();
        assert_eq!(env.peek(&0x0002.into()), 0x49);
    }

    #[test]
    pub fn test_assemble() {
        let tokens = vec![
            Token::Org {
                val1: Expr::Value(10),
                val2: None
            },
            Token::OpCode(
                Mnemonic::Ld,
                Some(DataAccess::Register8(Register8::A)),
                Some(DataAccess::Register8(Register8::L)),
                None
            ),
        ];

        let _count = visit_tokens(&tokens).unwrap().size();
        //       assert_eq!(count, 2);
    }

    #[test]
    pub fn test_listing_size() {
        let listing = parse_z80_str(
            "
.first_line
                    ; end code : 9 nops
    pop de              ; 4
    ld a, e             ; 1
    dec sp              ; 2
    jp  .other_lines + (9+4+1+2)                ; 4


.other_lines
    defs 64 - 4
    dec a               ; 1
    jr nz, .other_lines ; 3"
        )
        .expect("Unable to assemble");

        let size = listing.number_of_bytes();
        eprintln!("{:?}", size);
        assert!(size.is_ok());
        assert_eq!(size.ok().unwrap(), 1 + 1 + 1 + 3 + 60 + 1 + 2);
    }
}