ldpl 0.1.0

LDPL 4.4 compiler in Rust
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

//! The Builder wraps your C++ compiler and builds the final program.

use crate::{compiler::Compiler, LDPLResult};
use std::{fs, path::Path, process::Command, str};

impl Compiler {
    /// Run the local C++ compiler and build a binary.
    /// Returns the name of the built binary.
    pub fn build(&self, path: &str, outfile: Option<String>) -> LDPLResult<String> {
        // TODO better way to check errors after compiling
        if !self.expected_defs.is_empty() {
            for (sub, _) in &self.expected_defs {
                return error!("The subprocedure {} is called but never declared.", sub);
            }
        }

        let path = Path::new(&path);
        let target = if outfile.is_none() {
            format!(
                "{}/{}",
                path.parent()
                    .and_then(|d| Some(d.to_string_lossy()))
                    .unwrap_or(".".into()),
                path.file_stem()
                    .and_then(|f| Some(format!("{}-bin", f.to_string_lossy())))
                    .unwrap_or("ldpl-output-bin".into())
            )
            .trim_matches('/')
            .to_string()
        } else {
            outfile.unwrap().to_string()
        };

        let filename = "ldpl-temp.cpp";
        if Path::new(filename).exists() {
            fs::remove_file(filename)?;
        }
        fs::write(filename, self.to_string())?;

        let mut cmd = Command::new("c++");
        let mut cmd = cmd
            .arg("ldpl-temp.cpp")
            .arg("-std=gnu++11")
            .arg("-w")
            .arg("-o")
            .arg(&target);

        for flag in &self.flags {
            cmd = cmd.arg(flag);
        }
        for ext in &self.exts {
            cmd = cmd.arg(ext);
        }

        // run command
        let cmd = cmd.output();

        fs::remove_file(filename)?;

        let output = cmd?;
        if !output.stderr.is_empty() {
            return error!(
                "C++ Error compiling {}: \n{}",
                filename,
                str::from_utf8(&output.stderr).unwrap_or("UTF-8 Error in C++ output")
            );
        }

        Ok(target)
    }
}