Solution for issue#8

src/args.rs

@@ -4,14 +4,26 @@
 use clap::Parser;
 use const_format::formatcp;
 
+const SUBMAKE_FORBIDDEN_FLAGS: [&str; 5] = ["-j", "-C", "-f", "-o", "-W"];
+
+const BUILD_MODE: &str = if cfg!(debug_assertions) {
+    "Debug"
+} else {
+    "Release"
+};
+
 /// Represents the `clap`-based arguments provided by this binary.
 #[derive(Clone, Debug, Parser)]
 #[clap(
     name = "make (oxidized)",
     version,
     about,
     after_help = formatcp!(
-        "License:  {}\nSource:   {}", env!("CARGO_PKG_LICENSE"), env!("CARGO_PKG_REPOSITORY")
+        "License:     {}\nSource:      {}\nVersion:     {}\nBuild type:  {}", 
+        env!("CARGO_PKG_LICENSE"),
+        env!("CARGO_PKG_REPOSITORY"),
+        env!("CARGO_PKG_VERSION"),
+        BUILD_MODE
     ),
 )]
 pub struct Args {
@@ -56,3 +68,37 @@ pub struct Args {
     #[arg(long)]
     pub license: bool,
 }
+
+/// Converts the arguments to a string that can be passed to a sub-make invocation.
+pub fn args_to_submake_str() -> String {
+    // Rudimetary MAKEFLAGS parsing, the '-j' flag handling is not implemented yet.
+    // TODO: This should probably be a `Result` instead of a `panic!`.
+    // NOTE: Maybe change the way this is done to a pure IPC solution? when sub-make is used?
+    let args = std::env::args()
+        .collect::<Vec<_>>()
+        .iter()
+        .map(|arg| {
+            let mut arg_mod = arg.clone();
+
+            // If the argument contains a space, we need to quote it.
+            if arg_mod.contains(' ') {
+                arg_mod = format!("\"{}\"", arg_mod);
+            }
+
+            if arg_mod.starts_with("--") {
+                arg_mod = arg_mod[2..].to_string();
+            } else if arg_mod.starts_with('-') {
+                arg_mod = arg_mod[1..].to_string();
+            }
+
+            // remove special cases
+            if SUBMAKE_FORBIDDEN_FLAGS.contains(&arg_mod.as_str()) {
+                arg_mod = "".to_string();
+            }
+            arg_mod
+        })
+        .collect::<Vec<_>>()
+        .join(" ");
+
+    format!("-{}", args)
+}

src/vars.rs

@@ -30,12 +30,25 @@ pub struct Vars {
     // multiple allocations and lifetime tracking.
     blank: Var,
     default_recipe_prefix: Var,
+    make_var: Var,
+    makeargs_var: Var,
 }
 
 impl Vars {
     /// Primary interface for configuring a new instance. We also create some cached values that
     /// live for the lifetime of this instance to reduce the number of allocations.
     pub fn new<const N: usize>(init: [(&str, &str); N]) -> Self {
+        // Get the executable path for the `MAKE` variable.
+        let exe_path = match std::env::current_exe() {
+            // TODO: This should probably be a `Result` instead of a `panic!`.
+            // Try to canonicalize the path, but if that fails we panic because
+            // this means something is very wrong with the system.
+            Ok(path) => path.canonicalize().unwrap().to_string_lossy().into_owned(),
+            Err(_) => panic!("Unable to get executable path!"),
+        };
+
+
+
         let mut vars = Self {
             map: HashMap::new(),
             blank: Var {
@@ -46,6 +59,14 @@ impl Vars {
                 value: DEFAULT_RECIPE_PREFIX.to_string(),
                 recursive: false,
             },
+            make_var: Var {
+                value: exe_path,
+                recursive: false,
+            },
+            makeargs_var: Var {
+                value: crate::args::args_to_submake_str(),
+                recursive: false,
+            },
         };
 
         // Use `set` to initialize data.
@@ -61,6 +82,9 @@ impl Vars {
     pub fn get(&self, k: impl AsRef<str>) -> &Var {
         let k = k.as_ref().trim();
         match k {
+            // Special variables.
+            "MAKE" => &self.make_var,
+            "MAKEFLAGS" => &self.makeargs_var,
             ".RECIPEPREFIX" => match self.map.get(k) {
                 None => &self.default_recipe_prefix,
                 Some(var) => {
@@ -71,6 +95,7 @@ impl Vars {
                     }
                 }
             },
+            // Normal variables.
             _ => match self.map.get(k) {
                 None => &self.blank,
                 Some(var) => var,