tinywasm-cli 0.9.0-alpha.1

Minimal command-line interface for TinyWasm
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use clap::{
    Args, Parser, Subcommand, ValueEnum,
    builder::{
        Styles,
        styling::{AnsiColor, Effects},
    },
};
use clap_complete::Shell;

use crate::engine_flags::EngineFlags;

// based on https://github.com/crate-ci/clap-cargo/blob/master/src/style.rs
const STYLES: Styles = Styles::styled()
    .header(AnsiColor::BrightGreen.on_default().effects(Effects::BOLD))
    .usage(AnsiColor::BrightGreen.on_default().effects(Effects::BOLD))
    .literal(AnsiColor::BrightCyan.on_default().effects(Effects::BOLD))
    .placeholder(AnsiColor::Cyan.on_default())
    .error(AnsiColor::BrightRed.on_default().effects(Effects::BOLD))
    .valid(AnsiColor::BrightCyan.on_default().effects(Effects::BOLD))
    .invalid(AnsiColor::Yellow.on_default());

#[derive(Parser)]
#[command(
    name = "tinywasm",
    about = "TinyWasm CLI",
    styles = STYLES,
    version,
    args_conflicts_with_subcommands = true,
    subcommand_negates_reqs = true
)]
pub struct Cli {
    #[arg(long, global = true, value_enum, default_value_t = LogLevel::Info)]
    pub log_level: LogLevel,

    #[command(subcommand)]
    pub command: Option<Commands>,

    #[command(flatten)]
    pub run: RunArgs,
}

#[derive(Subcommand)]
pub enum Commands {
    /// Run a module
    Run(RunArgs),
    /// Compile a Wasm/WAT module to a .twasm archive
    Compile(CompileArgs),
    /// Dump lowered TinyWasm bytecode
    Dump(ModuleInputArgs),
    /// Inspect imports and exports
    Inspect(ModuleInputArgs),
    #[cfg(feature = "wast")]
    /// Execute WebAssembly spec scripts (.wast)
    Wast(WastArgs),
    /// Generate shell completions
    Completion(CompletionArgs),
}

#[derive(Args, Clone)]
pub struct RunArgs {
    /// Module path, or `-` to read from stdin
    pub module: Option<String>,

    /// Invoke a named export instead of the default entrypoint
    #[arg(long)]
    pub invoke: Option<String>,

    #[command(flatten)]
    pub engine: EngineFlags,

    /// Arguments passed to the invoked Wasm function
    #[arg(trailing_var_arg = true)]
    pub args: Vec<String>,
}

#[derive(Args, Clone)]
pub struct CompileArgs {
    /// Input module path, or `-` to read from stdin
    pub input: String,

    /// Output path, or `-` to write to stdout
    #[arg(short, long)]
    pub output: Option<String>,

    /// Overwrite the output file if it already exists
    #[arg(short, long)]
    pub force: bool,
}

#[derive(Args, Clone)]
pub struct ModuleInputArgs {
    /// Module path, or `-` to read from stdin
    pub module: String,
}

#[derive(Args, Clone)]
pub struct CompletionArgs {
    pub shell: Shell,
}

#[cfg(feature = "wast")]
#[derive(Args, Clone)]
pub struct WastArgs {
    /// WAST files or directories containing .wast files
    #[arg(required = true)]
    pub paths: Vec<String>,
}

#[derive(Clone, Copy, ValueEnum)]
pub enum LogLevel {
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

impl From<LogLevel> for log::LevelFilter {
    fn from(value: LogLevel) -> Self {
        match value {
            LogLevel::Trace => log::LevelFilter::Trace,
            LogLevel::Debug => log::LevelFilter::Debug,
            LogLevel::Info => log::LevelFilter::Info,
            LogLevel::Warn => log::LevelFilter::Warn,
            LogLevel::Error => log::LevelFilter::Error,
        }
    }
}