rustwasm/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/rustwasm/wasm-bindgen.git synced 2024-12-26 11:34:22 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Remove --wasm2js flag entirely

Browse Source
This commit is contained in:
Bradlee Speice 2018-09-03 13:56:55 -04:00
parent c69833f253
commit 0965b77af8
4 changed files with 4 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
crates/cli-support/src/wasm2es6js.rs
View File

@ -11,14 +11,12 @@ use parity_wasm::elements::*;
pub struct Config {
base64: bool,
wasm2js: bool,
fetch_path: Option<String>,
}
pub struct Output {
module: Module,
base64: bool,
wasm2js: bool,
fetch_path: Option<String>,
}
@ -26,7 +24,6 @@ impl Config {
pub fn new() -> Config {
Config {
base64: false,
wasm2js: false,
fetch_path: None,
}
}
@ -36,25 +33,19 @@ impl Config {
self
}
pub fn wasm2js(&mut self, wasm2js: bool) -> &mut Self {
self.wasm2js = wasm2js;
self
}
pub fn fetch(&mut self, path: Option<String>) -> &mut Self {
self.fetch_path = path;
self
}
pub fn generate(&mut self, wasm: &[u8]) -> Result<Output, Error> {
if !self.base64 && !self.fetch_path.is_some() && !self.wasm2js {
bail!("one of --base64, --fetch, or --wasm2js is required");
if !self.base64 && !self.fetch_path.is_some() {
bail!("one of --base64 or --fetch is required");
}
let module = deserialize_buffer(wasm)?;
Ok(Output {
module,
base64: self.base64,
wasm2js: self.wasm2js,
fetch_path: self.fetch_path.clone(),
})
}
@ -139,9 +130,6 @@ impl Output {
}
pub fn js(self) -> Result<String, Error> {
if self.wasm2js {
return self.js_wasm2js();
}
let mut js_imports = String::new();
let mut exports = String::new();
let mut set_exports = String::new();
@ -232,170 +220,6 @@ impl Output {
exports = exports,
))
}
fn js_wasm2js(self) -> Result<String, Error> {
let mut js_imports = String::new();
let mut imported_items = Vec::new();
if let Some(i) = self.module.import_section() {
let mut name_map = HashMap::new();
for (i, entry) in i.entries().iter().enumerate() {
match *entry.external() {
External::Function(_) => {}
External::Table(_) => {
bail!("wasm imports a table which isn't supported yet");
}
External::Memory(_) => {
bail!("wasm imports memory which isn't supported yet");
}
External::Global(_) => {
bail!("wasm imports globals which aren't supported yet");
}
}
let m = name_map.entry(entry.field()).or_insert(entry.module());
if *m != entry.module() {
bail!(
"the name `{}` is imported from two differnet \
modules which currently isn't supported in `wasm2js` \
mode"
);
}
let name = format!("import{}", i);
js_imports.push_str(&format!(
"import {{ {} as {} }} from '{}';\n",
entry.field(),
name,
entry.module()
));
imported_items.push((entry.field().to_string(), name));
}
}
let mut js_exports = String::new();
if let Some(i) = self.module.export_section() {
let mut export_mem = false;
for entry in i.entries() {
match *entry.internal() {
Internal::Function(_) => {}
Internal::Memory(_) => export_mem = true,
Internal::Table(_) => continue,
Internal::Global(_) => continue,
};
js_exports.push_str(&format!("export const {0} = ret.{0};\n", entry.field()));
}
if !export_mem {
bail!(
"the `wasm2js` mode is currently only compatible with \
modules that export memory"
)
}
}
let memory_size = self.module.memory_section().unwrap().entries()[0]
.limits()
.initial();
let mut js_init_mem = String::new();
if let Some(s) = self.module.data_section() {
for entry in s.entries() {
let offset = entry.offset().code();
if offset.len() != 2 {
bail!("don't recognize data offset {:?}", offset)
}
if offset[1] != Instruction::End {
bail!("don't recognize data offset {:?}", offset)
}
let offset = match offset[0] {
Instruction::I32Const(x) => x,
_ => bail!("don't recognize data offset {:?}", offset),
};
let base64 = base64::encode(entry.value());
js_init_mem.push_str(&format!("_assign({}, \"{}\");\n", offset, base64));
}
}
let td = tempfile::tempdir()?;
let wasm = serialize(self.module)?;
let wasm_file = td.as_ref().join("foo.wasm");
fs::write(&wasm_file, wasm)
.with_context(|_| format!("failed to write wasm to `{}`", wasm_file.display()))?;
let wast_file = td.as_ref().join("foo.wast");
run(
Command::new("wasm-dis")
.arg(&wasm_file)
.arg("-o")
.arg(&wast_file),
"wasm-dis",
)?;
let js_file = td.as_ref().join("foo.js");
run(
Command::new("wasm2js")
.arg(&wast_file)
.arg("-o")
.arg(&js_file),
"wasm2js",
)?;
let asm_func = fs::read_to_string(&js_file)
.with_context(|_| format!("failed to read `{}`", js_file.display()))?;
let mut make_imports = String::from(
"
var imports = {};
",
);
for (name, import) in imported_items {
make_imports.push_str(&format!("imports['{}'] = {};\n", name, import));
}
Ok(format!(
"\
{js_imports}
{asm_func}
const mem = new ArrayBuffer({mem_size});
const _mem = new Uint8Array(mem);
function _assign(offset, s) {{
if (typeof Buffer === 'undefined') {{
const bytes = atob(s);
for (let i = 0; i < bytes.length; i++)
_mem[offset + i] = bytes.charCodeAt(i);
}} else {{
const bytes = Buffer.from(s, 'base64');
for (let i = 0; i < bytes.length; i++)
_mem[offset + i] = bytes[i];
}}
}}
{js_init_mem}
{make_imports}
const ret = asmFunc({{
Math,
Int8Array,
Uint8Array,
Int16Array,
Uint16Array,
Int32Array,
Uint32Array,
Float32Array,
Float64Array,
NaN,
Infinity,
}}, imports, mem);
{js_exports}
",
js_imports = js_imports,
js_init_mem = js_init_mem,
asm_func = asm_func,
js_exports = js_exports,
make_imports = make_imports,
mem_size = memory_size * (1 << 16),
))
}
}
fn run(cmd: &mut Command, program: &str) -> Result<(), Error> {

3
crates/cli/src/bin/wasm2es6js.rs
View File

@ -24,7 +24,6 @@ Options:
--typescript Output a `*.d.ts` file next to the JS output
--base64 Inline the wasm module using base64 encoding
--fetch PATH Load module by passing the PATH argument to `fetch()`
--wasm2js Convert wasm to javascript and don't use `WebAssembly`
Note that this is not intended to produce a production-ready output module
but rather is intended purely as a temporary \"hack\" until it's standard in
@ -36,7 +35,6 @@ struct Args {
flag_output: Option<PathBuf>,
flag_typescript: bool,
flag_base64: bool,
flag_wasm2js: bool,
flag_fetch: Option<String>,
arg_input: PathBuf,
}
@ -62,7 +60,6 @@ fn rmain(args: &Args) -> Result<(), Error> {
let object = wasm_bindgen_cli_support::wasm2es6js::Config::new()
.base64(args.flag_base64)
.wasm2js(args.flag_wasm2js)
.fetch(args.flag_fetch.clone())
.generate(&wasm)?;

4
examples/asm.js/README.md
View File

@ -12,10 +12,6 @@ $ ./build.sh
When opened in a web browser this should print "Hello, World!" to the console.
This example uses the `wasm2es6js` tool to convert the wasm file to an ES module
that's implemented with asm.js instead of WebAssembly. The conversion to asm.js
is done by [binaryen]'s `wasm2js` tool internally.
Note that the `wasm2js` tool is still pretty early days so there's likely to be
a number of bugs to run into or work around. If any are encountered though
please feel free to report them upstream!

7
examples/asm.js/build.sh
View File

@ -12,11 +12,8 @@ cargo +nightly run --manifest-path ../../crates/cli/Cargo.toml \
--no-demangle \
../../target/wasm32-unknown-unknown/release/asmjs.wasm --out-dir .
# Run the `wasm2es6js` primarily with the `--wasm2js` flag, which will
# internally execute `wasm2js` as necessary
cargo +nightly run --manifest-path ../../crates/cli/Cargo.toml \
--bin wasm2es6js -- \
asmjs_bg.wasm --wasm2js -o asmjs_bg.js
# Run the `wasm2js` tool from `binaryen`
wasm2js asmjs_bg.wasm -o asmjs_bg.js
# Move our original wasm out of the way to avoid cofusing Webpack.
mv asmjs_bg.wasm asmjs_bg.bak.wasm