Add clone-gcc command

Author: GuillaumeGomez

build_system/src/clone_gcc.rs

@@ -0,0 +1,79 @@
+use crate::config::ConfigInfo;
+use crate::utils::{git_clone, run_command_with_output};
+
+use std::path::{Path, PathBuf};
+
+fn show_usage() {
+    println!(
+        r#"
+`clone-gcc` command help:
+
+    --out-path         : Location where the GCC repository will be cloned (default: `./gcc`)"#
+    );
+    ConfigInfo::show_usage();
+    println!("    --help                 : Show this help");
+}
+
+#[derive(Default)]
+struct Args {
+    out_path: PathBuf,
+    config_info: ConfigInfo,
+}
+
+impl Args {
+    fn new() -> Result<Option<Self>, String> {
+        let mut command_args = Self::default();
+
+        let mut out_path = None;
+
+        // We skip binary name and the `clone-gcc` command.
+        let mut args = std::env::args().skip(2);
+
+        while let Some(arg) = args.next() {
+            match arg.as_str() {
+                "--out-path" => match args.next() {
+                    Some(path) if !path.is_empty() => out_path = Some(path),
+                    _ => {
+                        return Err("Expected an argument after `--out-path`, found nothing".into())
+                    }
+                },
+                "--help" => {
+                    show_usage();
+                    return Ok(None);
+                }
+                arg => {
+                    if !command_args.config_info.parse_argument(arg, &mut args)? {
+                        return Err(format!("Unknown option {}", arg));
+                    }
+                }
+            }
+        }
+        command_args.out_path = match out_path {
+            Some(p) => p.into(),
+            None => PathBuf::from("./gcc"),
+        };
+        return Ok(Some(command_args));
+    }
+}
+
+pub fn run() -> Result<(), String> {
+    let Some(args) = Args::new()? else {
+        return Ok(());
+    };
+
+    let result = git_clone("https://github.com/antoyo/gcc", Some(&args.out_path), false)?;
+    if result.ran_clone {
+        let gcc_commit = args.config_info.get_gcc_commit()?;
+        println!("Checking out GCC commit `{}`...", gcc_commit);
+        run_command_with_output(
+            &[&"git", &"checkout", &gcc_commit],
+            Some(Path::new(&result.repo_dir)),
+        )?;
+    } else {
+        println!(
+            "There is already a GCC folder in `{}`, leaving things as is...",
+            args.out_path.display()
+        );
+    }
+    Ok(())
+}

build_system/src/config.rs

@@ -192,9 +192,7 @@ impl ConfigInfo {
         command
     }
 
-    fn download_gccjit_if_needed(&mut self) -> Result<(), String> {
-        let output_dir = Path::new(crate::BUILD_DIR).join("libgccjit");
-
+    pub fn get_gcc_commit(&self) -> Result<String, String> {
         let commit_hash_file = self.compute_path("libgccjit.version");
         let content = fs::read_to_string(&commit_hash_file).map_err(|_| {
             format!(
@@ -212,7 +210,14 @@ impl ConfigInfo {
                 commit,
             ));
         }
-        let output_dir = output_dir.join(commit);
+        Ok(commit.to_string())
+    }
+
+    fn download_gccjit_if_needed(&mut self) -> Result<(), String> {
+        let output_dir = Path::new(crate::BUILD_DIR).join("libgccjit");
+        let commit = self.get_gcc_commit()?;
+
+        let output_dir = output_dir.join(&commit);
         if !output_dir.is_dir() {
             std::fs::create_dir_all(&output_dir).map_err(|err| {
                 format!(

build_system/src/main.rs

@@ -4,6 +4,7 @@ use std::process;
 mod build;
 mod cargo;
 mod clean;
+mod clone_gcc;
 mod config;
 mod info;
 mod prepare;
@@ -27,19 +28,21 @@ fn usage() {
         "\
 Available commands for build_system:
 
-    cargo    : Run cargo command
-    clean    : Run clean command
-    prepare  : Run prepare command
-    build    : Run build command
-    test     : Run test command
-    info:    : Run info command
-    --help   : Show this message"
+    cargo     : Run cargo command
+    clean     : Run clean command
+    prepare   : Run prepare command
+    build     : Run build command
+    test      : Run test command
+    info      : Run info command
+    clone-gcc : Run clone-gcc command
+    --help    : Show this message"
     );
 }
 
 pub enum Command {
     Cargo,
     Clean,
+    CloneGcc,
     Prepare,
     Build,
     Test,
@@ -58,6 +61,7 @@ fn main() {
         Some("build") => Command::Build,
         Some("test") => Command::Test,
         Some("info") => Command::Info,
+        Some("clone-gcc") => Command::CloneGcc,
         Some("--help") => {
             usage();
             process::exit(0);
@@ -77,6 +81,7 @@ fn main() {
         Command::Build => build::run(),
         Command::Test => test::run(),
         Command::Info => info::run(),
+        Command::CloneGcc => clone_gcc::run(),
     } {
         eprintln!("Command failed to run: {e}");
         process::exit(1);

build_system/src/test.rs

@@ -487,15 +487,10 @@ fn setup_rustc(env: &mut Env, args: &TestArg) -> Result<PathBuf, String> {
     );
     let rust_dir_path = Path::new(crate::BUILD_DIR).join("rust");
     // If the repository was already cloned, command will fail, so doesn't matter.
-    let _ = run_command_with_output_and_env(
-        &[
-            &"git",
-            &"clone",
-            &"https://github.com/rust-lang/rust.git",
-            &rust_dir_path,
-        ],
-        None,
-        Some(env),
+    let _ = git_clone(
+        "https://github.com/rust-lang/rust.git",
+        Some(&rust_dir_path),
+        false,
     );
     let rust_dir: Option<&Path> = Some(&rust_dir_path);
     run_command(&[&"git", &"checkout", &"--", &"tests/"], rust_dir)?;