wars 0.8.1

Wasm to Rust converter
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

use std::{
    borrow::Cow,
    collections::{BTreeMap, BTreeSet},
    convert::Infallible,
    f32::consts::E,
    iter::once,
    sync::{Arc, OnceLock},
};
// use pit_core::{Arg, Interface};
use proc_macro2::{Span, TokenStream};
use quasiquote::quasiquote;
use quote::{format_ident, quote, ToTokens};

use sha3::Digest;
use syn::{Ident, Lifetime};

pub(crate) mod pit;
pub struct MemImport {
    pub expr: TokenStream,
    // pub(crate) r#type: TokenStream
}
pub trait Plugin {
    fn pre(&self, module: &mut OptsCore) -> anyhow::Result<()>;
    fn import(
        &self,
        opts: &OptsCore,
        module: &str,
        name: &str,
        params: Vec<TokenStream>,
    ) -> anyhow::Result<Option<TokenStream>>;
    fn mem_import(
        &self,
        opts: &OptsCore,
        module: &str,
        name: &str,
    ) -> anyhow::Result<Option<MemImport>> {
        Ok(None)
    }
    fn post(&self, opts: &OptsCore) -> anyhow::Result<TokenStream>;
    fn bounds(&self, opts: &OptsCore) -> anyhow::Result<Option<TokenStream>> {
        Ok(None)
    }
    fn exref_bounds(&self, opts: &OptsCore) -> anyhow::Result<Option<TokenStream>> {
        Ok(None)
    }
}
bitflags::bitflags! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    pub struct Flags: u32{
        // const HOST_MEMORY = 0x1;
        const ASYNC = 0x2;
        const LEGACY = 0x4;
        // const WASIX = 0x8;
        // const BIND = 0x10;
        // const PIT = 0x20;
        // const UNSANDBOXED = 0x2;
        const NEW_ABI = 0x100;
        const NEW_BACKEND = 0x200;
    }
}
pub(crate) mod unswitch;
// pub(crate) mod wasix;

#[derive(Clone)]
pub struct OptsLt<'a, B> {
    pub module: B,
    pub core: OptsCore<'a>,
    // pub(crate) cfg: Arc<dyn ImportCfg>,
}
#[derive(Clone)]
pub struct OptsCore<'a> {
    pub crate_path: syn::Path,
    pub bytes: &'a [u8],
    pub name: Ident,
    pub flags: Flags,
    pub embed: TokenStream,
    pub data: BTreeMap<Ident, TokenStream>,
    pub roots: BTreeMap<String, TokenStream>,
    pub plugins: Vec<Arc<dyn Plugin + 'a>>,
}
impl<'a> OptsCore<'a> {
    pub fn inflate(self) -> OptsLt<'a, &'a [u8]> {
        OptsLt {
            module: self.bytes,
            core: self,
        }
    }
}
pub type Opts<B> = OptsLt<'static, B>;
// pub(crate) trait ImportCfg {
//     fn import(&self, module: &str, name: &str) -> TokenStream;
// }
pub(crate) const INTRINSIC: &'static str = "wars_intrinsic/";
pub(crate) mod r#impl;