spaik 0.3.1

The SPAIK Programming Language
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

use crate::{nkgc::SymID, swym::SwymDb};
use crate::chasm::ASMOp;
use crate::nuke::NkSum;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
pub struct SymEntry {
    name: String,
    sym: SymID,
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
pub struct Import {
    path: Vec<SymID>,
    syms: Vec<SymID>,
}

impl Import {
    pub fn new(path: &[SymID], imports: &[SymID]) -> Import {
        Import {
            path: path.to_vec(),
            syms: imports.to_vec()
        }
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ModuleMeta {
    name_len: u32,
    name: Vec<u8>,
    spaik_ver: (u16, u16, u16),
    mod_ver: (u16, u16, u16),
}

#[derive(Deserialize, Serialize, Clone, Copy, PartialEq, Eq, Debug)]
#[repr(u8)]
pub enum ExportKind {
    Func,
    Macro,
    Var
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
pub struct Export {
    kind: ExportKind,
    name: SymID,
    pos: u32,
}

impl Export {
    pub fn new(kind: ExportKind, name: SymID, pos: u32) -> Export {
        Export { kind, name, pos }
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub enum Const {
    String(String),
}

#[derive(Serialize, Deserialize, Debug)]
pub struct LispModule {
    symtbl: Vec<SymEntry>,
    imports: Vec<Import>,
    exports: Vec<Export>,
    consts: Vec<Const>,
    pmem: Vec<u8>,
}

impl LispModule {
    pub fn new<ASM>(pmem_in: &[ASM],
                    symtbl_in: &SwymDb,
                    iconsts: &[NkSum],
                    imports: Vec<Import>,
                    exports: Vec<Export>) -> LispModule
        where ASM: ASMOp
    {
        let mut pmem = vec![];
        for op in pmem_in.iter() {
            op.write(&mut pmem).unwrap();
        }
        let mut symtbl = vec![];
        #[allow(unused_variables)]
        for (sym, name) in symtbl_in.iter() {
            #[allow(unreachable_code)]
            symtbl.push(todo!("symbol entry for modules"));
        }
        let mut consts = vec![];
        consts.extend(iconsts.iter().map(|c| match c {
            NkSum::String(s) => Const::String(s.clone()),
            _ => unimplemented!("Only string constants are supported as module exports"),
        }));
        LispModule {
            symtbl,
            exports,
            imports,
            consts,
            pmem,
        }
    }
}