lasm 0.1.0

A tiny and portable assembly language for complex compilers
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

use crate::{asm, Error, Result};
use alloc::{
    string::{String, ToString},
    vec::Vec,
};
use core::fmt::Display;

/// The Ast object stores the entire abstract syntax tree
#[derive(Clone, Debug, PartialEq, PartialOrd)]
pub struct Ast {
    procs: Vec<Procedure>,
}

impl Ast {
    /// Create an Ast object from a list of procedures
    pub(crate) fn new(procs: Vec<Procedure>) -> Self {
        Self { procs }
    }

    /// Lower the list of procedures into a list of instructions.
    /// Procedures are not stored in memory, but are inlined instead.
    /// All this method does is resolve all `call` instructions.
    pub fn lower(self) -> Result<Vec<asm::Instruct>> {
        let mut entry_proc = Procedure::new(Procedure::ENTRY_POINT, Vec::new());

        for prc in &self.procs {
            if prc.is_entry_point() {
                entry_proc = prc.clone();
            }
        }

        entry_proc.lower(&self.procs)
    }
}

/// This represents an instruction in an assembly file
#[derive(Clone, Debug, PartialEq, PartialOrd)]
pub(crate) enum Exec {
    /// This is not used by the user, but is used internally for simplicity
    Nop,

    /// A procedure call
    Call(String),

    /// An assembly instruction
    Assembly(asm::Instruct),
}

impl Exec {
    /// Create a call instruction
    pub fn call(name: impl Display) -> Self {
        Self::Call(name.to_string())
    }

    /// Create an assembly instruction
    pub fn asm(i: asm::Instruct) -> Self {
        Self::Assembly(i)
    }
}

/// The Procedure struct is only
#[derive(Clone, Debug, PartialEq, PartialOrd)]
pub(crate) struct Procedure {
    /// The name of the procedure
    name: String,

    /// The list of instructions the procedure will execute when called
    code: Vec<Exec>,
}

impl Procedure {
    /// The name of the entry point function
    const ENTRY_POINT: &'static str = "start";

    pub fn new(name: impl Display, code: Vec<Exec>) -> Self {
        Self {
            name: name.to_string(),
            code,
        }
    }

    pub fn get_name(&self) -> String {
        self.name.clone()
    }

    pub fn is_entry_point(&self) -> bool {
        self.get_name() == Self::ENTRY_POINT
    }

    pub fn is_proc(&self, name: impl Display) -> bool {
        self.get_name() == name.to_string()
    }

    pub fn lower(&self, procs: &[Self]) -> Result<Vec<asm::Instruct>> {
        let mut result = Vec::new();
        for expr in &self.code {
            match expr {
                Exec::Nop => {}
                Exec::Call(name) => {
                    let mut proc_exists = false;
                    for prc in procs {
                        if prc.is_proc(&name) {
                            proc_exists = true;
                            result.extend(prc.lower(procs)?);
                            break;
                        }
                    }

                    if !proc_exists {
                        return Err(Error::ProcedureNotDefined(name.clone()));
                    }
                }
                Exec::Assembly(i) => result.push(i.clone()),
            }
        }
        Ok(result)
    }
}