about summary refs log tree commit diff
path: root/src/compiler.rs
blob: f925b267df57ca49d5220b6d0f5fc607d6b72e1d (plain) (blame)
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
use std::fmt::{self, Display};
use std::path::Path;
use std::str::FromStr;
use std::{fs, result};

use clap::Clap;
use test_strategy::Arbitrary;

use crate::codegen::{self, Codegen};
use crate::common::Result;
use crate::{parser, tc};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Arbitrary)]
pub enum OutputFormat {
    LLVM,
    Bitcode,
}

impl Default for OutputFormat {
    fn default() -> Self {
        Self::Bitcode
    }
}

impl FromStr for OutputFormat {
    type Err = String;

    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
        match s {
            "llvm" => Ok(Self::LLVM),
            "binary" => Ok(Self::Bitcode),
            _ => Err(format!(
                "Invalid output format {}, expected one of {{llvm, binary}}",
                s
            )),
        }
    }
}

impl Display for OutputFormat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OutputFormat::LLVM => f.write_str("llvm"),
            OutputFormat::Bitcode => f.write_str("binary"),
        }
    }
}

#[derive(Clap, Debug, PartialEq, Eq, Default)]
pub struct CompilerOptions {
    #[clap(long, short = 'f', default_value)]
    format: OutputFormat,
}

pub fn compile_file(input: &Path, output: &Path, options: &CompilerOptions) -> Result<()> {
    let src = fs::read_to_string(input)?;
    let (_, decls) = parser::toplevel(&src)?; // TODO: statements
    let decls = tc::typecheck_toplevel(decls)?;

    let context = codegen::Context::create();
    let mut codegen = Codegen::new(
        &context,
        &input
            .file_stem()
            .map_or("UNKNOWN".to_owned(), |s| s.to_string_lossy().into_owned()),
    );
    for decl in &decls {
        codegen.codegen_decl(decl)?;
    }
    match options.format {
        OutputFormat::LLVM => codegen.print_to_file(output)?,
        OutputFormat::Bitcode => codegen.binary_to_file(output)?,
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use test_strategy::proptest;

    #[proptest]
    fn output_format_display_from_str_round_trip(of: OutputFormat) {
        assert_eq!(OutputFormat::from_str(&of.to_string()), Ok(of));
    }
}