corge-rs 0.1.1

A small Rust-powered build tool for C projects: init, build, deps, profiles, and tooling.
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

use std::process::Command;
use std::str::FromStr;
use target_lexicon::{OperatingSystem, Triple};
use crate::std_command_ext::ExecuteCommand;

#[derive(Debug)]
pub enum Extension {
    Object,
    Executable,
    StaticLibrary,
    DynamicLibrary,
}

impl Extension {
    fn linux_extension(&self) -> Option<String> {
        match self {
            Extension::Object => Some("o".to_string()),
            Extension::Executable => None,
            Extension::StaticLibrary => Some("a".to_string()),
            Extension::DynamicLibrary => Some("so".to_string())
        }
    }
    fn macos_extension(&self) -> Option<String> {
        match self {
            Extension::Object => Some("o".to_string()),
            Extension::Executable => None,
            Extension::StaticLibrary => Some("a".to_string()),
            Extension::DynamicLibrary => Some("dylib".to_string())
        }
    }
    fn windows_extension(&self) -> Option<String> {
        match self {
            Extension::Object => Some("obj".to_string()),
            Extension::Executable => Some("exe".to_string()),
            Extension::StaticLibrary => Some("lib".to_string()),
            Extension::DynamicLibrary => Some("dll".to_string())
        }
    }

    fn for_triple(&self, target_triple: &str) -> Option<String> {
        let operating_system =
            match Triple::from_str(target_triple) {
                Ok(triple) => triple.operating_system,
                Err(_) => OperatingSystem::Linux
            };

        match operating_system {
            OperatingSystem::Linux => self.linux_extension(),
            OperatingSystem::MacOSX(_) => self.macos_extension(),
            OperatingSystem::Windows => self.windows_extension(),
            _ => self.linux_extension(),
        }
    }

    fn for_compiler(&self, compiler: &str) -> Option<String> {
        log::info!("{:?}. Getting extention for compiler: {}", &self, compiler);
        let stdout = Command::new(compiler)
            .arg("-dumpmachine")
            .execute(true)
            .expect(format!("Failed to execute: {} -dumpmachine", compiler).as_str());

        /* fixme */
        let triple = stdout.strip_suffix("\n").unwrap().to_string();

        self.for_triple(&triple)
    }

    pub fn file_name(&self, name: &str, compiler: &str) -> String {
        let extension = match self.for_compiler(compiler) {
            None => "",
            Some(extension) => &format!(".{}", extension),
        };

        match self {
            Extension::Object => format!("{}{}", name, extension),
            Extension::Executable =>  format!("{}{}", name, extension),
            Extension::StaticLibrary => format!("lib{}{}", name, extension),
            Extension::DynamicLibrary => format!("lib{}{}", name, extension),
        }
    }
}