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
134
135
136

use std::{fs, path::Path};

use clap::Parser;
use ezio::prelude::*;
use serde::{Deserialize, Serialize};
use shadow_rs::shadow;

shadow!(build);

#[derive(Serialize, Deserialize, Debug)]
enum Target {
    #[serde(alias = "riscv")]
    RISCV,
    #[serde(alias = "wasm")]
    WASM,
    #[serde(alias = "shuorv")]
    SHUORV,
}

#[derive(Serialize, Deserialize, Debug)]
struct Config {
    #[serde(default)]
    optimization: Vec<String>,
    #[serde(default)]
    emit_ir: bool,
    #[serde(default)]
    emit_asm: bool,
    target: Target,
}

/// Come language build system
#[derive(clap::Parser, Debug)]
#[command(version, long_version = build::CLAP_LONG_VERSION, about, long_about = None)]
struct Args {
    #[command(subcommand)]
    action: Action,
}

#[derive(clap::Subcommand, Debug, PartialEq, PartialOrd, Ord, Eq, Clone)]
enum Action {
    /// Build a come project
    Build,
    /// Create a new come project
    New { name: String },
}

fn main() {
    let args = Args::parse();
    let current_dir = std::env::current_dir().unwrap();
    match args.action {
        Action::Build => {
            let config_path = current_dir.join("road.toml");
            let target_dir = current_dir.join("target");
            let asm_path = current_dir
                .join("target")
                .join(current_dir.file_name().unwrap());
            let result_path = current_dir.join(current_dir.file_name().unwrap());
            let config = file::read(config_path);
            let config: Config = toml::from_str(&config).unwrap();
            match config.target {
                Target::RISCV => {
                    compile_to_asm(target_dir, &current_dir, &asm_path, config);
                    std::process::Command::new("shuasm")
                        .arg("-i")
                        .arg(format!("{}.asm", asm_path.display()))
                        .arg("-o")
                        .arg(current_dir.join(format!("{}.clef", asm_path.to_str().unwrap())))
                        .output()
                        .expect("failed to execute assembler");
                    std::process::Command::new("linker")
                        .arg("-i")
                        .arg(current_dir.join(format!("{}.clef", asm_path.to_str().unwrap())))
                        .arg("-o")
                        .arg(current_dir.join(format!("{}.clef", result_path.to_str().unwrap())))
                        .output()
                        .expect("failed to execute linker");
                }
                Target::WASM => {
                    unimplemented!()
                }
                Target::SHUORV => {
                    unimplemented!()
                }
            }
        }
        Action::New { name } => {
            let project_dir = current_dir.join(name);
            fs::create_dir_all(&project_dir).unwrap();
            let config = Config {
                optimization: vec![
                    "RemoveOnlyOnceStore".to_string(),
                    "RemoveLoadDirectlyAfterStore".to_string(),
                    "RemoveUnusedRegister".to_string(),
                    "MemoryToRegister".to_string(),
                    "RemoveUnusedRegister".to_string(),
                ],
                emit_ir: false,
                target: Target::RISCV,
                emit_asm: true,
            };
            let config = toml::to_string(&config).unwrap();
            file::write(project_dir.join("road.toml"), &config);
            file::write(project_dir.join("main.come"), "fn main() -> () {}");
        }
    }
}

fn compile_to_asm(
    target_dir: impl AsRef<Path>,
    current_dir: impl AsRef<Path>,
    target_filename: impl AsRef<Path>,
    config: Config,
) {
    let target_dir = target_dir.as_ref();
    let current_dir = current_dir.as_ref();
    fs::create_dir_all(target_dir).unwrap();
    let mut compiler_cmd = std::process::Command::new("come");
    compiler_cmd
        .arg("-i")
        .arg(current_dir.join("main.come").display().to_string())
        .arg("-o")
        .arg(format!(
            "{}.asm",
            target_dir.join(&target_filename).display()
        ));
    if config.emit_ir {
        compiler_cmd
            .arg("--emit-ir")
            .arg(format!("{}.ir", target_dir.join(target_filename).display()));
    }
    if !config.optimization.is_empty() {
        let optimization = config.optimization.join(",");
        compiler_cmd.arg("-O").arg(&optimization);
    }
    compiler_cmd.output().expect("failed to execute compiler");
}