awa5_rs 0.1.2

An AWA5.0 CLI tool written in Rust (btw)
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

pub mod awasm {
    use crate::{Awatism, Instruction};

    pub fn parse_lines(lines: impl Iterator<Item = String>) -> Vec<Instruction> {
        lines.filter_map(|line| parse_line(&line)).collect()
    }

    pub fn parse_line(line: &str) -> Option<Instruction> {
        let line_without_comments = line.split(';').next().unwrap_or("");
        let trimmed = line_without_comments.trim();
        let tokens: Vec<&str> = trimmed.split_whitespace().collect();

        if tokens.is_empty() || trimmed.starts_with(';') {
            return None;
        }

        let awatism = match tokens[0] {
            "nop" if tokens.len() == 1 => Awatism::Nop,
            "prn" if tokens.len() == 1 => Awatism::Prn,
            "pr1" if tokens.len() == 1 => Awatism::Pr1,
            "red" if tokens.len() == 1 => Awatism::Red,
            "r3d" if tokens.len() == 1 => Awatism::R3d,
            "blo" if tokens.len() == 2 => Awatism::Blo(tokens[1].parse().ok()?),
            "sbm" if tokens.len() == 2 => Awatism::Sbm(tokens[1].parse().ok()?),
            "pop" if tokens.len() == 1 => Awatism::Pop,
            "dpl" if tokens.len() == 1 => Awatism::Dpl,
            "srn" if tokens.len() == 2 => Awatism::Srn(tokens[1].parse().ok()?),
            "mrg" if tokens.len() == 1 => Awatism::Mrg,
            "4dd" if tokens.len() == 1 => Awatism::Add,
            "sub" if tokens.len() == 1 => Awatism::Sub,
            "mul" if tokens.len() == 1 => Awatism::Mul,
            "div" if tokens.len() == 1 => Awatism::Div,
            "cnt" if tokens.len() == 1 => Awatism::Cnt,
            "lbl" if tokens.len() == 2 => Awatism::Lbl(tokens[1].parse().ok()?),
            "jmp" if tokens.len() == 2 => Awatism::Jmp(tokens[1].parse().ok()?),
            "eql" if tokens.len() == 1 => Awatism::Eql,
            "lss" if tokens.len() == 1 => Awatism::Lss,
            "gr8" if tokens.len() == 1 => Awatism::Gr8,
            "trm" if tokens.len() == 1 => Awatism::Trm,
            _ => return None,
        };

        Some(Instruction { awatism })
    }
}

pub mod awatalk {
    use crate::{Awatism, Instruction};

    pub fn parse_string(content: &str) -> Vec<Instruction> {
        let mut instructions = Vec::new();

        let normalized = content
            .chars()
            .filter(|&c| c == 'a' || c == 'w' || c == ' ')
            .collect::<String>()
            .split_whitespace()
            .collect::<Vec<&str>>()
            .join(" ");

        if !normalized.starts_with("awa") {
            panic!("Not valid awatalk");
        }
        let mut remaining = &normalized[3..];

        let mapping = [(" awa", '0'), ("wa", '1')];

        let mut binary_str = String::new();
        let mut found_op = false;
        let mut num_bits = 0;
        let mut op_index = 0;
        let mut arg_index = 0;
        let mut current_index = 0;
        let mut arg_opcode = 0x00;
        while !remaining.is_empty() {
            let mut matched = false;
            let mut opcode = 0x00;
            for &(pattern, bit) in &mapping {
                if remaining.starts_with(pattern) {
                    binary_str.push(bit);
                    remaining = &remaining[pattern.len()..];
                    matched = true;
                    current_index += 1;

                    // finish reading args, add op code instruction
                    if found_op && current_index - arg_index == num_bits {
                        let op_str = &binary_str[arg_index..current_index];
                        let arg = u8::from_str_radix(op_str, 2).unwrap();
                        instructions.push(Instruction {
                            awatism: Awatism::from_u8(arg_opcode, arg).unwrap(),
                        });
                        op_index = current_index;
                        found_op = false;
                    }

                    // found op code
                    if !found_op && current_index - op_index == 5 {
                        let op_str = &binary_str[op_index..current_index];
                        opcode = u8::from_str_radix(op_str, 2).unwrap();
                        op_index = current_index;
                        found_op = true;
                    }

                    // set start of arg check
                    if found_op && Awatism::needs_args(opcode) {
                        arg_index = current_index;
                        arg_opcode = opcode;
                        num_bits = Awatism::arg_bits(opcode);
                    }

                    // does op code not needs args and continue checking, add instruction
                    if found_op && op_index == current_index && !Awatism::needs_args(opcode) {
                        instructions.push(Instruction {
                            awatism: Awatism::from_u8(opcode, 0x00).unwrap(),
                        });
                        found_op = false;
                    }

                    break;
                }
            }
            if !matched {
                break; // invalid awa code
            }
        }

        instructions
    }
}