limage 0.5.0

A Cargo utility for running/testing Rust-based kernels using the Limine bootloader
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

use anyhow::{anyhow, Result};
use std::path::PathBuf;

pub enum LimageCommand {
    Build,
    Run(LimageArgs),
    Version,
    Help,
}

impl LimageCommand {
    pub fn parse_args<A>(args: A) -> Result<Self>
    where
        A: Iterator<Item = String>,
    {
        let mut executable = None;
        let mut build_only = false;
        let mut arg_iter = args.fuse();

        let mut args_count = -1;
        loop {
            args_count += 1;

            let next = match arg_iter.next() {
                Some(next) => next,
                None => break,
            };

            match next.as_str() {
                "--help" | "-h" => {
                    return Ok(LimageCommand::Help);
                },
                "--version" | "-v" => {
                    return Ok(LimageCommand::Version);
                },
                "build" => {
                    build_only = true;
                },
                exe => {
                    executable = Some(PathBuf::from(exe));
                }
            }
        }

        if args_count < 2 {
            build_only = true;
        }

        let executable_or_error = executable.ok_or_else(|| anyhow!("expected path to kernel executable as first argument"))?;
        if build_only {
            Ok(Self::Build)
        } else {
            Ok(Self::Run(LimageArgs {executable: executable_or_error}))
        }
    }
}

#[derive(Debug, Clone)]
pub struct LimageArgs {
    pub executable: PathBuf
}