wasmonkey 0.1.17

Patch a WASM object file to replace a set of exported functions with imported functions from another library
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::path::PathBuf;

use clap::Arg;

use crate::{PatcherConfig, WError};

#[derive(Default, Clone, Debug)]
pub struct Config {
    pub input_path: PathBuf,
    pub output_path: PathBuf,
    pub patcher_config: PatcherConfig,
}

impl Config {
    pub fn parse_cmdline() -> Result<Self, WError> {
        let matches = clap::command!()
            .arg(
                Arg::new("input_file")
                    .short('i')
                    .long("input")
                    .takes_value(true)
                    .required(true)
                    .help("Path to the input file"),
            )
            .arg(
                Arg::new("output_file")
                    .short('o')
                    .long("output")
                    .takes_value(true)
                    .required(true)
                    .help("Path to the output file"),
            )
            .arg(
                Arg::new("builtins_file")
                    .short('b')
                    .long("builtins")
                    .takes_value(true)
                    .required(false)
                    .help("Path to the builtins library"),
            )
            .arg(
                Arg::new("builtins_additional")
                    .short('B')
                    .long("builtins-additional")
                    .takes_value(true)
                    .required(false)
                    .multiple_occurrences(true)
                    .help("Additional builtins function names to replace"),
            )
            .arg(
                Arg::new("builtins_map_file")
                    .short('m')
                    .long("builtins-map")
                    .takes_value(true)
                    .required(false)
                    .help("Path to the builtins map file"),
            )
            .arg(
                Arg::new("builtins_map_original_names")
                    .short('n')
                    .long("original-names")
                    .takes_value(false)
                    .required(false)
                    .help("Use the original name as a key in the builtins map"),
            )
            .get_matches();
        let input_path = PathBuf::from(
            matches
                .value_of("input_file")
                .ok_or(WError::UsageError("Input file required"))?,
        );
        let output_path = PathBuf::from(
            matches
                .value_of("output_file")
                .ok_or(WError::UsageError("Output file required"))?,
        );
        let builtins_path = matches.value_of("builtins_file").map(PathBuf::from);
        let builtins_map_path = matches.value_of("builtins_map_file").map(PathBuf::from);
        let builtins_map_original_names = matches.is_present("builtins_map_original_names");
        let builtins_additional = matches
            .values_of("builtins_additional")
            .unwrap_or_default()
            .map(|name| name.to_string())
            .collect();
        let config = Config {
            input_path,
            output_path,
            patcher_config: PatcherConfig {
                builtins_path,
                builtins_map_path,
                builtins_map_original_names,
                builtins_additional,
            },
        };
        Ok(config)
    }
}