Function parse_args

src/cli/main.rs:121–188

()

        }
    }
}

// --- Argument parsing ---

fn parse_args() -> Result<Args, CliError> {
    let raw: Vec<String> = std::env::args().skip(1).collect();
    let mut iter = raw.iter();

    let subcmd = match iter.next().map(|s| s.as_str()) {
        Some("link") => Subcommand::Link,
        Some("build") => Subcommand::Build,
        Some("hll-to-ir") => Subcommand::HllToIr,
        Some("hll-to-asm") => Subcommand::HllToAsm,
        Some("run") => Subcommand::Run,
        Some("help" | "--help" | "-h") | None => Subcommand::Help,
        Some(other) => {
            return Err(CliError::Usage(format!(
                "unknown subcommand `{other}`\n\nRun `fsc help` for usage."
            )));
        }
    };

    let mut inputs: Vec<String> = Vec::new();
    let mut output: Option<String> = None;
    let mut mode = TargetMode::Hosted;
    let mut max_steps = 50_000_000u64;
    let mut emit_object = false;

    while let Some(arg) = iter.next() {
        match arg.as_str() {
            "--output" | "-o" => {
                let path = iter
                    .next()
                    .ok_or_else(|| CliError::Usage("--output requires a file path".to_owned()))?;
                output = Some(path.clone());
            }
            "--mode" | "-m" => {
                let val = iter.next().ok_or_else(|| {
                    CliError::Usage("--mode requires `hosted` or `freestanding`".to_owned())
                })?;
                mode = parse_mode(val.as_str())?;
            }
            "--max-steps" => {
                let val = iter.next().ok_or_else(|| {
                    CliError::Usage("--max-steps requires a positive integer".to_owned())
                })?;
                max_steps = val
                    .parse::<u64>()
                    .map_err(|_| CliError::Usage(format!("`{val}` is not a valid step count")))?;
            }
            "--emit-o" => {
                emit_object = true;
            }
            other if !other.starts_with('-') => {
                inputs.push(other.to_owned());
            }
            other => {
                return Err(CliError::Usage(format!(