Method execute

crates/environ/examples/factc.rs:54–103

(self)

impl Factc {
    fn execute(self) -> Result<()> {
        env_logger::init();

        let input = wat::parse_file(&self.input)?;

        let tunables = Tunables::default_host();
        let mut validator =
            wasmparser::Validator::new_with_features(wasmparser::WasmFeatures::all());
        let mut component_types = ComponentTypesBuilder::new(&validator);
        let adapters = ScopeVec::new();

        Translator::new(&tunables, &mut validator, &mut component_types, &adapters)
            .translate(&input)?;

        let (out_name, mut out_file): (_, Box<dyn std::io::Write>) = match &self.output {
            Some(file) => (
                file.as_path(),
                Box::new(std::io::BufWriter::new(
                    std::fs::File::create(file)
                        .with_context(|| format!("failed to create {}", file.display()))?,
                )),
            ),
            None => (Path::new("stdout"), Box::new(std::io::stdout())),
        };

        for wasm in adapters.into_iter() {
            let output = if self.text {
                wasmprinter::print_bytes(&wasm)
                    .to_wasmtime_result()
                    .context("failed to convert binary wasm to text")?
                    .into_bytes()
            } else if self.output.is_none() && std::io::stdout().is_terminal() {
                bail!("cannot print binary wasm output to a terminal unless `-t` flag is passed")
            } else {
                wasm.to_vec()
            };

            out_file
                .write_all(&output)
                .with_context(|| format!("failed to write to {}", out_name.display()))?;

            if !self.skip_validate {
                Validator::new_with_features(WasmFeatures::default() | WasmFeatures::MEMORY64)
                    .validate_all(&wasm)
                    .context("failed to validate generated module")?;
            }
        }

        Ok(())
    }
}